diff --git a/01_0_Introduction.md b/01_0_Introduction.md index ae78733f4..452f9883b 100644 --- a/01_0_Introduction.md +++ b/01_0_Introduction.md @@ -6,7 +6,7 @@ The ways that we make payments for goods and services has been changing dramatic These centralization risks were some of the prime catalysts behind the creation of cryptocurrencies, the first and most successful of which is Bitcoin. Bitcoin offers pseudonymity; it makes it difficult to correlate transactions; and it makes censorship by individual entities all but impossible. These advantages have made it one of the quickest growing currencies in the world. That growth in turn has made Bitcoin into a going concern among entrepreneurs and developers, eager to create new services for the Bitcoin community. -If you're one of those entrepreneurs or developers, then this course is for you, because it's all about learning to program Bitcoin. It's an introductory course that explains all the nuances and features of Bitcoin as it goes. It also takes a very specific tack, by offering lessons in how to work _directly_ with Bitcoin Core and with the c-lightning server using their RPC interfaces. +If you're one of those entrepreneurs or developers, then this course is for you, because it's all about learning to program Bitcoin. It's an introductory course that explains all the nuances and features of Bitcoin as it goes. It also takes a very specific tack, by offering lessons in how to work _directly_ with Bitcoin Core and with the core lightning server using their RPC interfaces. Why not use some of the more fully featured libraries found in various programming languages? Why not create your own from scratch? It's because working with cryptocurrency is dangerous. There are no safety nets. If you accidentally overpay your fees or lose a signing key or create an invalid transaction or make any number of potential mistakes, then your cryptocurrency will be gone forever. Much of that responsibility will, of course, lie with you as a cryptocurrency programmer, but it can be minimized by working with the most robust, secure, and safe cryptocurrency interfaces around, the ones created by the cryptocurrency programming teams themselves: ``bitcoind`` and ``lightningd``. diff --git a/01_1_Introducing_Bitcoin.md b/01_1_Introducing_Bitcoin.md index e8e9bcb0c..9a32308d4 100644 --- a/01_1_Introducing_Bitcoin.md +++ b/01_1_Introducing_Bitcoin.md @@ -56,7 +56,7 @@ ECC does not receive much attention in this tutorial. That's because this tutori **_What is an Elliptic Curve?_** An elliptic curve is a geometric curve that takes the form `y``2` = `x``3`` + ax + b`. A specific elliptic curve is chosen by selecting specific values of `a` and `b`. The curve must then be carefully examined to determine if it works well for cryptography. For example, the secp256k1 curve used by Bitcoin is defined as `a=0` and `b=7`. -Any line that intersects an elliptic curve will do so at either 1 or 3 points ... and that's the basis of elliptic-curve cryptography. +Any line that intersects an elliptic curve will typically do so at 3 points (absent a few cases for infinity and intersections) ... and that's the basis of elliptic-curve cryptography. **_What are Finite Fields?_** A finite field is a finite set of numbers, where all addition, subtraction, multiplication, and division is defined so that it results in other numbers also in the same finite field. One simple way to create a finite field is through the use of a modulo function. @@ -80,7 +80,7 @@ Though you need to understand the basics of how a blockchain works to understand **_Why Is It Called a Chain?_** Each block in the blockchain stores a hash of the block before it. This links the current block all the way back to the original "genesis block" through an unbroken chain. It's a way to create absolute order among possibly conflicting data. This also provides the security of blockchain, because each block is stacked atop an old one makes it harder to recreate the old block due to the proof-of-work algorithms used in block creation. Once several blocks have been built atop a block in the chain, it's essentially irreversible. -**_What is a Fork?_** Occasionally two blocks are created around the same time. This temporarily creates a one-block fork, where either if the current blocks could be the "real" one. Every once in a while, a fork might expand to become two blocks, three blocks, or even four blocks long, but pretty quickly one side of the fork is determined to be the real one, and the other is "orphaned". This is part of the stochastic process of block creation, and demonstrates why several blocks must be built atop a block before it can be considered truly trustworthy and non-repudiable. +**_What is a Fork?_** Occasionally two blocks are created around the same time. This temporarily creates a one-block fork, where either of the current blocks could be the "real" one. Every once in a while, a fork might expand to become two blocks, three blocks, or even four blocks long, but pretty quickly one side of the fork is determined to be the real one, and the other is "orphaned". This is part of the stochastic process of block creation, and demonstrates why several blocks must be built atop a block before it can be considered truly trustworthy and non-repudiable. ### Blockchain — In Short @@ -123,7 +123,7 @@ Lightning is a layer-2 protocol that interacts with Bitcoin to allow users to ex Lightning is also the secondary focus of this tutorial. Though it's mostly about interacting directly with Bitcoin (and the `bitcoind`), it pays some attention to Lightning because it's an upcoming technology that is likely to become a popular alternative to Bitcoin in the near future. This book takes the same approach to Lightning as to Bitcoin: it teaches how to interact directly with a trusted Lightning daemon from the command line. -Unlike with Bitcoin, there are actually several variants of Lightning. This tutorial uses the standard-compliant [c-lightning](https://github.com/ElementsProject/lightning) implementation as its trusted Lightning server. +Unlike with Bitcoin, there are actually several variants of Lightning. This tutorial uses the standard-compliant [core lightning](https://github.com/ElementsProject/lightning) implementation as its trusted Lightning server. **_What is a Layer-2 Protocol?_** A layer-2 Bitcoin protocol works on top of Bitcoin. In this case, Lightning works atop Bitcoin, interacting with it through smart contracts. diff --git a/02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md b/02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md index be25b2fc8..4c57c3f23 100644 --- a/02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md +++ b/02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md @@ -1,6 +1,6 @@ # 2.1: Setting Up a Bitcoin-Core VPS with Bitcoin Standup -This document explains how to set up a VPS (Virtual Private Sever) to run a Bitcoin node on Linode.com, installed using an automated StackScript from the [Bitcoin Standup project](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). You just need to enter a few commands and boot your VPS. Almost immediately after you boot, you'll find your new Bitcoin node happily downloading blocks. +This document explains how to set up a VPS (Virtual Private Sever) to run a Bitcoin node on Linode.com using an automated StackScript from the [Bitcoin Standup project](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). You just need to enter a few commands and boot your VPS. Almost immediately after you boot, you'll find your new Bitcoin node happily downloading blocks. > :warning: **WARNING:** Don’t use a VPS for a bitcoin wallet with significant real funds; see http://blog.thestateofme.com/2012/03/03/lessons-to-be-learned-from-the-linode-bitcoin-incident/ . It is very nice to be able experiment with real bitcoin transactions on a live node without tying up a self-hosted server on a local network. It's also useful to be able to use an iPhone or iPad to communicate via SSH to your VPS to do some simple bitcoin tasks. But a higher level of safety is required for significant funds. @@ -10,7 +10,7 @@ This document explains how to set up a VPS (Virtual Private Sever) to run a Bitc ## Getting Started with Linode -Linode is a Cloud Hosting service that offers quick, cheap Linux servers with SSD storage. We use them for this tutorial primarily because their BASH-driven StackScripts offer an easy way to automatically set up a Bitcoin node with no fuss and no muss. +Linode (now Akamai Cloud) is a Cloud Hosting service that offers quick, cheap Linux servers with SSD storage. We use them for this tutorial primarily because their BASH-driven StackScripts offer an easy way to automatically set up a Bitcoin node with no fuss and no muss. ### Set Up a Linode Account @@ -26,74 +26,74 @@ If you prefer, the following referral code will give you two months worth of fre You'll need to provide an email address and later preload money from a credit card or PayPal for future costs. -When you're done, you should land on [https://cloud.linode.com/dashboard](https://cloud.linode.com/dashboard). +When you're done, you should land on [https://cloud.linode.com/linodes](https://cloud.linode.com/linodes). ### Consider Two-Factor Authentication -Your server security won't be complete if people can break into your Linode account, so consider setting up Two-Factor Authentication for it. You can find this setting on your [My Profile: Password & Authentication page](https://manager.linode.com/profile/auth). If you don't do this now, make a TODO item to come back and do it later. +Your server security won't be complete if people can break into your Linode account, so consider setting up Two-Factor Authentication for it. You can find this setting on your [My Profile: Password & Authentication page](https://cloud.linode.com/profile/auth). If you don't do this now, make a TODO item to come back and do it later. ## Creating the Linode Image using a StackScript ### Load the StackScript -Download the [Linode Standup Script](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) from the [Bitcoin Standup Scripts repo](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). This script basically automates all Bitcoin VPS setup instructions. If you want to be particulary prudent, read it over carefully. If you are satisfied, you can copy that StackScript into your own account by going to the [Stackscripts page](https://cloud.linode.com/stackscripts?type=account) on your Linode account and selecting to [Create New Stackscript](https://cloud.linode.com/stackscripts/create). Give it a good name (we use `Bitcoin Standup`), then copy and paste the script. Choose Debian 12 for your target image and "Save" it. +Download the [Linode Standup Script](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) from the [Bitcoin Standup Scripts repo](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). This script basically automates all Bitcoin VPS setup instructions. If you want to be particulary prudent, read it over carefully. If you are satisfied, you can copy that StackScript into your own account by going to the [Stackscripts page](https://cloud.linode.com/stackscripts) on your Linode account and selecting to [Create New Stackscript](https://cloud.linode.com/stackscripts/create). Give it a good name (we use `Bitcoin Standup`), then copy and paste the script. Choose Debian 13 for your target image and "Save" it. ### Do the Initial Setup You're now ready to create a node based on the Stackscript. 1. On the [Stackscripts page](https://cloud.linode.com/stackscripts?type=account), click on the "..." to the right of your new script and choose "Deploy New Linode". -2. Fill in a short and a fully qualified hostname +2. Enter the password for the "standup" user. This will be the account that runs `bitcoind`. +3. Fill in a short and a fully qualified hostname * **Short Hostname.** Pick a name for your VPS. For example, "mybtctest". * **Fully Qualified Hostname.** If you're going to include this VPS as part of a network with full DNS records, type in the hostname with its domain. For example, "mybtctest.mydomain.com". Otherwise, just repeat the short hostname and add ".local", for example "mybtctest.local". -3. Enter the password for the "standup" user. 4. Fill in the appropriate advanced options. - * **X25519 Public Key.** This is a public key to add to Tor's list of authorized clients. If you don't use it, anyone who gets the QR code for your node can access it. You'll get this public key from whichever client you're using to connect to your node. For example, if you use [FullyNoded 2](https://github.com/BlockchainCommons/FullyNoded-2), you can go to its settings and "Export Tor V3 Authentication Public Key" for use here. - * **Installation Type.** This is likely "Mainnet" or "Pruned Mainnet" if you are setting up a node for usage and "Testnet" or "Pruned Testnet" if you're just playing around. The bulk of this tutorial will assume you chose "Pruned Testnet", but you should still be able to follow along with other types. See the [Synopsis](#synopsis-bitcoin-installation-types) for more information on these options. (Note that if you plan to try out the Lightning chapters, you'll probably want to use an Unpruned node, as working with Pruned nodes on Lightning is iffy. See [§18.1](18_1_Verifying_Your_Lightning_Setup.md#compiling-the-source-code) for the specifics.) - * **SSH Key.** Copy your local computer's SSH key here; this allows you be able to automatically login in via SSH to the standup account. If you haven't setup an SSH key on your local computer yet, there are good instructions for it on [Github](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/). You may also want to add your SSH key into your Linode LISH (Linode Interactive Shell) by going to your "Linode Home Page / My Preferences / LISH Settings / LISH Keys". Using an SSH key will give you a simpler and safer way to log in to your server. - * **SSH-Allowed IPs.** This is a comma-separated list of IPs that will be allowed to SSH into the VPS. For example "192.168.1.15,192.168.1.16". If you do not enter any IPs, _your VPS will not be very secure_. It will constantly be bombarded by attackers trying to find their way in, and they may very well succeed. + * **Installation Type.** This is likely "Mainnet" or "Pruned Mainnet" if you are setting up a node for usage and "Signet" or "Pruned Signet" if you're just playing around. The bulk of this tutorial will assume you chose "Pruned Signet", but you should still be able to follow along with other types. See the [Synopsis](#synopsis-bitcoin-installation-types) for more information on these options. (Note that if you plan to try out the Lightning chapters, you'll probably want to use an Unpruned node, as working with Pruned nodes on Lightning is iffy. See [§18.1](18_1_Verifying_Your_Lightning_Setup.md#compiling-the-source-code) for the specifics.) + * **Timezone.** The timezone your machine is set to. + * **Security: Tor X25519 Public Key.** This is a public key to add to Tor's list of authorized clients. If you don't use it, anyone who gets the QR code for your node can access it. You'll get this public key from whichever client you're using to connect to your node. For example, if you use [FullyNoded 2](https://github.com/BlockchainCommons/FullyNoded-2), you can go to its settings and "Export Tor V3 Authentication Public Key" for use here. + * **Security: Standup SSH Key.** Copy your local computer's SSH key here; this allows you be able to automatically login in via SSH to the standup account. If you haven't setup an SSH key on your local computer yet, there are good instructions for it on [Github](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/). Using an SSH key will give you a simpler and safer way to log in to your server. + * **Security: SSH-Allowed IPs.** This is a comma-separated list of IPs that will be allowed to SSH into the VPS. For example "192.168.1.15,192.168.1.16". If you do not enter any IPs, _your VPS will not be very secure_. It will constantly be bombarded by attackers trying to find their way in, and they may very well succeed. + * **Cypherpunkpay.** These are options to install Cypherpunkpay on your server. They're primarily intended for other users of the Standup software and aren't used in this course, so you can just leave them be. +4. Choose a region for where the Linode will be located. 5. Select an Image - * **Target Image.** If you followed the instructions, this will only allow you to select "Debian 12" (though previous versions of this Stackscript worked with Debian 9 or 10 or 12 and might still). -6. Choose a region for where the Linode will be located. - -*The remaining questions all have to do with the mechanics of the VPS deployment and should be left as they are with one exception: bump the Swap Disk from 256MB to 512MB, to ensure that you have enough memory to download the blockchain.* - -### Choose Other Standup Options - -Blockchain Commons is currently in the process of expanding its Bitcoin Standup Scripts with options to install Lightning and other Bitcoin apps of note. Take a look at any extra options, and see if they're things that you'd like to play with. In particular, if Lightning is an option, we suggest installing it, because it will make [Chapter 18](18_0_Understanding_Your_Lightning_Setup.md) and [Chapter 19](19_0_Using_Lightning.md) much easier. + * **Target Image.** If you followed the instructions, this will only allow you to select "Debian 13" (though previous versions of this Stackscript worked with Debian 9 through 12, and might still.) ### Choose a Linode Plan -You'll next to choose a Linode plan. +You'll next need to choose a Linode plan. -Linode will default to Dedicated-CPU plans, but you can select the more cost-efficient Shared-CPU instead. A Shared-CPU Linode 4GB will suffice for most setups, including: Pruned Mainnet, Pruned Testnet, and even non-Pruned Testnet. They all use less than 50G of storage and 4GB is a comfortable amount of memory. This is the setup we suggest. It runs $20 per month. +Linode will default to Dedicated-CPU plans, but you can select the more cost-efficient Shared-CPU instead. A Shared-CPU Linode 4GB will suffice for most setups, including: Pruned Mainnet, Pruned Testnet, Pruned Signet, and even non-Pruned Signet. They all use less than 50G of storage and 4GB is a comfortable amount of memory. This is the setup we suggest. It runs $20 per month. -If you want to instead have a non-Pruned Mainnet in a VPS, you'll need to install a Linode with a disk in excess of 280G(!), which is currently the Linode 16GB, which has 320G of storage and 16G of memory and costs approximately $80 per month. We do _not_ suggest this. +If you want to instead have a non-Pruned Mainnet in a VPS, you'll need to install a Linode with a disk in excess of 715G(!), which is currently the Linode 64 GB, which has 1280G of storage and 64G of memory and costs approximately $384 per month. We do _not_ suggest this. (But see below for alternatives.) The following chart shows minimum requirements -| Setup | Memory | Storage | Linnode | +| Setup | Memory | Storage | Linode | |-------|--------|---------|---------| -| Mainnet | 2G | 280G | Linode 16GB | +| Mainnet | 2G | ~715G | Linode 64GB | | Pruned Mainnet | 2G | ~5G | Linode 4GB | -| Testnet | 2G | ~15G | Linode 4GB | +| Signet | 2G | ~15G | Linode 4GB | +| Pruned Signet | 2G | ~5G | Linode 4GB | +| Testnet | 2G | ~170G | Linode 16GB | | Pruned Testnet | 2G | ~5G | Linode 4GB | | Regtest | 2G | ~ | Linode 4GB | Note, there may be ways to reduce both costs. -* For the machines we suggest as **Linode 4GB**, you may be able to reduce that to a Linode 2GB. Some versions of Bitcoin Core have worked well at that size, some have occasionally run out of memory and then recovered, and some have continuously run out of memory. Remember to up that swap space to maximize the odds of this working. Use at your own risk. -* For the Unpruned Mainnet, which we suggest as a **Linode 16GB**, you can probably get by with a Linode 4GB, but add [Block Storage](https://cloud.linode.com/volumes) sufficient to store the blockchain. This is certainly a better long-term solution since the Bitcoin blockchain's storage requirements continuously increase if you don't prune, while the CPU requirements don't (or don't to the same degree). A 320 GibiByte storage would be $32 a month, which combined with a Linode 4GB is $52 a month, instead of $80, and more importantly you can keep growing it. We don't fully document this setup for two reasons (1) we don't suggest the unpruned mainnet setup, and so we suspect it's a much less common setup; and (2) we haven't tested how Linodes volumes compare to their intrinic SSDs for performance and usage. But there's full documentation on the Block Storage page. You'd need to set up the Linode, run its stackscript, but then interrupt it to move the blockchain storage overly to a newly commissioned volume before continuing. +* For the setups we suggest as **Linode 4GB**, you may be able to reduce that to a Linode 2GB. Some versions of Bitcoin Core have worked well at that size, some have occasionally run out of memory and then recovered, and some have continuously run out of memory. Remember to up that swap space to maximize the odds of this working. Use at your own risk. +* For the Unpruned Mainnet, which we suggest as a **Linode 64GB**, you can probably get by with a Linode 4GB, but add [Block Storage](https://cloud.linode.com/volumes/create) sufficient to store the blockchain. This is certainly a better long-term solution since the Bitcoin blockchain's storage requirements continuously increase if you don't prune, while the CPU requirements don't (or don't to the same degree). A 750 GibiByte storage would be $75 a month, which combined with a Linode 4GB is $95 a month, instead of $384, and more importantly you can keep growing it. We don't fully document this setup for two reasons (1) we don't suggest the unpruned mainnet setup, and so we suspect it's a much less common setup; and (2) we haven't tested how Linodes volumes compare to their intrinic SSDs for performance and usage. But there's full documentation on the Block Storage page. You'd need to set up the Linode, run its stackscript, but then interrupt it to move the blockchain storage over to a newly commissioned volume before continuing. If you are running a deployment that will be transacting real Bitcoins, you may want to alternatively consider a Dedicated-CPU Linode, which tends to run 50% more expensive than the Shared-CPU Linode. We've generally found the Shared CPUs to be entirely sufficient, but for a wide deployment, you may wish to consider higher levels of reliability. ### Do the Final Setup -The last thing you need to do is enter a root password. (If you missed anything, you'll be told so now!) +You may now want to change your Linode VPS's name from the default `linodexxxxxxxx`. For instance you might name it `bitcoin-signet-pruned` to differentiate it from other VPSs in your account. -Click "Deploy" to initialize your disks and to prepare your VPS. The whole queue should run in less than a minute. When it's done you should see in the "Host Job Queue", green "Success" buttons stating "Disk Create from StackScript - Setting password for root… done." and "Create Filesystem - 256MB Swap Image". +The last thing you need to do is enter a root password. (If you missed anything, you'll be told so now!). You'll also have the option to add an SSH key for the root user aat this point. We again suggest doing so for both security and convenience purposes. -You may now want to change your Linode VPS's name from the default `linodexxxxxxxx`. Go to the Settings tab, and change the label to be more useful, such as your VPS's short hostname. For instance you might name it `bitcoin-testnet-pruned` to differentiate it from other VPSs in your account. +Linode at this point offers a few choices that have changed over time, but currently include: disk encryption, VPC, firewall, and VLAN. These are generally security features that you would want to consider for a real-world deployment, but don't need to worry about for a testing deployment. (We'd suggest at least a firewall and the disk encryption for a real-world deployment, but we leave that to you and your security people.) + +Click "Deploy" to initialize your disks and to prepare your VPS. The whole queue should run in less than a minute. When it's done you should see in the "Host Job Queue", green "Success" buttons stating "Disk Create from StackScript - Setting password for root… done." and "Create Filesystem - 256MB Swap Image". ## Login to Your VPS @@ -125,7 +125,7 @@ If you're impatient you can jump ahead and `sudo tail -f /standup.log` which wil ## Verify Your Installation -You'll know that stackscrpit is done when the `tail` of the `standup.log` says something like the following: +You'll know that stackscript is done when the `tail` of the `standup.log` says something like the following: ``` /root/StackScript - Bitcoin is setup as a service and will automatically start if your VPS reboots and so is Tor /root/StackScript - You can manually stop Bitcoin with: sudo systemctl stop bitcoind.service @@ -135,7 +135,9 @@ At that point, your home directory should look like this: ``` $ ls -bitcoin-22.0-x86_64-linux-gnu.tar.gz keys.txt SHA256SUMS SHA256SUMS.asc +bitcoin-30.2-x86_64-linux-gnu.tar.gz wget-btc-output.txt +SHA256SUMS wget-btc-sha-asc-output.txt +SHA256SUMS.asc wget-btc-sha-output.txt ``` These are the various files that were used to install Bitcoin on your VPS. _None_ of them are necessary. We've just left them in case you want to do any additional verification. Otherwise, you can delete them: @@ -155,24 +157,23 @@ $ sudo grep VERIFICATION /standup.log If you see something like the following, all should be well: ``` -./standup.sh - SIG VERIFICATION SUCCESS: 9 GOOD SIGNATURES FOUND. -./standup.sh - SHA VERIFICATION SUCCESS / SHA: bitcoin-22.0-x86_64-linux-gnu.tar.gz: OK +/root/StackScript - SIG VERIFICATION SUCCESS: 8 GOOD SIGNATURES FOUND. +/root/StackScript - SHA VERIFICATION SUCCESS / SHA: bitcoin-30.2-x86_64-linux-gnu.tar.gz: OK ``` If either of those two checks instead reads "VERIFICATION ERROR", then there's a problem. The log also contains more information on the Signatures, if you want to make sure you know _who_ signed the Bitcoin release: ``` $ sudo grep -i good /standup.log -./standup.sh - SIG VERIFICATION SUCCESS: 9 GOOD SIGNATURES FOUND. -gpg: Good signature from "Andrew Chow (Official New Key) " [unknown] -gpg: Good signature from "Ben Carman " [unknown] -gpg: Good signature from "Antoine Poinsot " [unknown] +/root/StackScript - SIG VERIFICATION SUCCESS: 8 GOOD SIGNATURES FOUND. +gpg: Good signature from ".0xB10C " [unknown] +gpg: Good signature from "Ava Chow " [unknown] gpg: Good signature from "Stephan Oeste (it) " [unknown] gpg: Good signature from "Michael Ford (bitcoin-otc) " [unknown] gpg: Good signature from "Oliver Gugger " [unknown] -gpg: Good signature from "Hennadii Stepanov (hebasto) " [unknown] -gpg: Good signature from "Jon Atack " [unknown] -gpg: Good signature from "Wladimir J. van der Laan " [unknown] +gpg: Good signature from "Hennadii Stepanov (GitHub key) <32963518+hebasto@users.noreply.github.com>" [unknown] +gpg: Good signature from "Matthew Zipkin (GitHub Signing Key) " [unknown] +gpg: Good signature from "Sjors Provoost " [unknown] ``` Since this is all scripted, it's possible that there's just been a minor change that has caused the script's checks not to work right. (This has happened a few times over the existence of the script that became Standup.) But, it's also possible that someone is trying to encourage you to run a fake copy of the Bitcoin daemon. So, _be very sure you know what happened before you make use of Bitcoin!_ @@ -196,7 +197,7 @@ If all look good, congratulations, you have a functioning Bitcoin node using Lin ## What We Have Wrought -Although the default Debian 12 image that we are using for your VPS has been modified by Linode to be relatively secure, your Bitcoin node as installed through the Linode StackScript is set up with an even higher level of security. You may find this limiting, or be unable to do things that you expect. Here are a few notes on that: +Although the default Debian 13 image that we are using for your VPS has been modified by Linode to be relatively secure, your Bitcoin node as installed through the Linode StackScript is set up with an even higher level of security. You may find this limiting, or be unable to do things that you expect. Here are a few notes on that: ### Protected Services @@ -235,9 +236,9 @@ So now you probably want to play with Bitcoin! But wait, your Bitcoin daemon is probably still downloading blocks. The `bitcoin-cli getblockcount` will tell you how you're currently doing: ``` $ bitcoin-cli getblockcount -1771352 +288191 ``` -If it's different every time you type the command, you need to wait before working with Bitcoin. This takes 1-6 hours currently for a pruned setup, depending on your precise machine. +If it's different every time you type the command, you need to wait before working with Bitcoin. This can take hours for a mainnet setup, but if you're using our suggested setup of pruned signet, it should be done in 15 minutes or so. But, once it settles at a number, you're ready to continue! @@ -262,7 +263,11 @@ You have a few options for what's next: **Pruned Mainnet.** This will cut the blockchain you're storing down to just the last 550 blocks. If you're not mining or running some other Bitcoin service, this should be plenty for validation. -**Testnet.** This gives you access to an alternative Bitcoin blockchain where the Bitcoins don't actually have value. It's intended for experimentation and testing. +**Signet.** This is the newest iteration of a testing network, where Bitcoins don't actually have value, and has largely surpassed Testnet. It's intended for experimentation and testing. Its big advantage is that its block production is more reliable that Testnet, where Testnet could stall out for a while, then produce a bunch of blocks together. + +**Pruned Signet.** The last 550 blocks of Signet. + +**Testnet.** The older testing network, still useful to some for the ability for miners to force block reorgs (and likely for other specific testing purposes). It's currently `testnet3`, but we expect it to be updated to `testnet4` in the near future (which should drop down the current large size of the blockchain). **Pruned Testnet.** This is just the last 550 blocks of Testnet ... because the Testnet blockchain is pretty big now too. diff --git a/04_2__Interlude_Using_JQ.md b/04_2__Interlude_Using_JQ.md index b516fe2a4..698beefa6 100644 --- a/04_2__Interlude_Using_JQ.md +++ b/04_2__Interlude_Using_JQ.md @@ -372,7 +372,7 @@ $ usedtxid=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | . $ usedvout=($(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vin | .[] | .vout')) $ btcin=$(for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout')) | .amount'; done | awk '{s+=$1} END {print s}') $ btcout=$(bitcoin-cli decoderawtransaction $rawtxhex | jq -r '.vout [] | .value' | awk '{s+=$1} END {print s}') -$ echo "$btcin-$btcout"| /usr/bin/bc +$ echo $(printf '%.8f-%.8f' $btcin $btcout_f) | /usr/bin/bc .255 ``` And that's also a good example of why you double-check your fees: we'd intended to send a transaction fee of 5,000 satoshis, but sent 255,000 satoshis instead. Whoops! diff --git a/05_3_Funding_a_Transaction_with_CPFP.md b/05_3_Funding_a_Transaction_with_CPFP.md index 9ec05b9d8..c74d881f2 100644 --- a/05_3_Funding_a_Transaction_with_CPFP.md +++ b/05_3_Funding_a_Transaction_with_CPFP.md @@ -82,7 +82,7 @@ $ bitcoin-cli getrawtransaction 95d51e813daeb9a861b2dcdddf1da8c198d06452bbbecfd8 ``` Look through the `vout` array. Find the object that matches your address. (Here, it's the only one.) The `n` value is your `vout`. You now have everything you need to create a new CPFP transaction. ``` -$ utxo_txid=2NFAkGiwnp8wvCodRBx3smJwxncuG3hndn5 +$ utxo_txid=95d51e813daeb9a861b2dcdddf1da8c198d06452bbbecfd827447881ff79e061 $ utxo_vout=0 $ recipient2=$(bitcoin-cli getrawchangeaddress) ``` diff --git a/08_1_Sending_a_Transaction_with_a_Locktime.md b/08_1_Sending_a_Transaction_with_a_Locktime.md index 1db607cd1..beee88595 100644 --- a/08_1_Sending_a_Transaction_with_a_Locktime.md +++ b/08_1_Sending_a_Transaction_with_a_Locktime.md @@ -42,7 +42,7 @@ Once you've figured out the current height, you can decide how far in the future Once you have figured out your locktime, all you need to do is write up a typical raw transaction, with a third variable for `locktime`: ``` -$ rawtxhex=$(bitcoin-cli -named createrawtransaction inputs='''[ { "txid": "'$utxo_txid'", "vout": '$utxo_vout' } ]''' outputs='''{ "'$recipient'": 0.001, "'$changeaddress'": 0.00095 }''' locktime=1774650) +$ rawtxhex=$(bitcoin-cli -named createrawtransaction inputs='''[ { "txid": "'$utxo_txid'", "vout": '$utxo_vout' } ]''' outputs='''[{ "'$recipient'": 0.001, "'$changeaddress'": 0.00095 }]''' locktime=1774650) ``` Note that this usage of `locktime` is under 500 million, which means that it defines a block height. In this case, it's just a few blocks past the current block height at the time of this writing, meant to exemplify how locktime works without sitting around for a long time to wait and see what happens. diff --git a/10_2_Building_the_Structure_of_P2SH.md b/10_2_Building_the_Structure_of_P2SH.md index 7d74afe05..28c78cf54 100644 --- a/10_2_Building_the_Structure_of_P2SH.md +++ b/10_2_Building_the_Structure_of_P2SH.md @@ -106,9 +106,9 @@ Here's what the individual parts mean: * 0x52 = OP_2 * 0x21 = OP_PUSHDATA 33 bytes (hex: 0x21) -* 0x02da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d191 = the next 33 bytes (public-key hash) +* 0x02da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d191 = the next 33 bytes (public key) * 0x21 = OP_PUSHDATA 33 bytes (hex: 0x21) -* 0x02bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa3 = the next 33 bytes (public-key hash) +* 0x02bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa3 = the next 33 bytes (public key) * 0x52 = OP_2 * 0xae = OP_CHECKMULTISIG diff --git a/10_4_Scripting_a_Multisig.md b/10_4_Scripting_a_Multisig.md index 4aab0a13d..f779e9fae 100644 --- a/10_4_Scripting_a_Multisig.md +++ b/10_4_Scripting_a_Multisig.md @@ -4,17 +4,19 @@ Before we close out this intro to P2SH scripting, it's worth examining a more re ## Understand the Multisig Code -Multisig transactions are created in Bitcoin using the `OP_CHECKMULTISIG` code. `OP_CHECKMULTISIG` expects a long string of arguments that looks like this: `0 ... sigs ... ... addresses ... OP_CHECKMULTISIG`. When `OP_CHECKMULTISIG` is run, it does the following: +Multisig transactions are created in Bitcoin using the `OP_CHECKMULTISIG` code. `OP_CHECKMULTISIG` expects a long string of arguments that looks like this: `0 ... sigs ... ... public keys ... OP_CHECKMULTISIG`. When `OP_CHECKMULTISIG` is run, it does the following: 1. Pop the first value from the stack (``). -2. Pop "n" values from the stack as Bitcoin addresses (hashed public keys). +2. Pop "n" values from the stack as public keys. 3. Pop the next value from the stack (``). 4. Pop "m" values from the stack as potential signatures. 5. Pop a `0` from the stack due to a mistake in the original coding. -6. Compare the signatures to the Bitcoin adddresses. +6. Compare the signatures to the public keys. 7. Push a `True` or `False` depending on the result. -The operands of `OP_MULTISIG` are typically divided, with the `0` and the signatures coming from the unlocking script and the "m", "n", and addresses being detailed by the locking script. +The operands of `OP_MULTISIG` are typically divided, with the `0` and +the signatures coming from the unlocking script and the "m", "n", and +public keys being detailed by the locking script. The requirement for that `0` as the first operand for `OP_CHECKMULTISIG` is a consensus rule. Because the original version of `OP_CHECKMULTISIG` accidentally popped an extra item off the stack, Bitcoin must forever follow that standard, lest complex redemption scripts from that time period accidentally be broken, rendering old funds unredeemable. @@ -24,11 +26,11 @@ The requirement for that `0` as the first operand for `OP_CHECKMULTISIG` is a co As discussed in [§10.1: Understanding the Foundation of P2SH](10_1_Understanding_the_Foundation_of_P2SH.md), multisigs are one of the standard Bitcoin transaction types. A transaction can be created with a locking script that uses the raw `OP_CHECKMULTISIG` command, and it will be accepted into a block. This is the classic methodology for using multisigs in Bitcoin. -As an example, we will revisit the multisig created in [§6.1](06_1_Sending_a_Transaction_to_a_Multisig.md) one final time and build a new locking script for it using this methodology. As you may recall, that was a 2-of-2 multisig built from `$address1` and `$address2`. +As an example, we will revisit the multisig created in [§6.1](06_1_Sending_a_Transaction_to_a_Multisig.md) one final time and build a new locking script for it using this methodology. As you may recall, that was a 2-of-2 multisig built from `$pubkey1` and `$pubkey2`. -As `OP_CHECKMULTISIG` locking script requires the "m" (`2`), the addresses, and the "n" (`2`), you could write the following `scriptPubKey`: +As `OP_CHECKMULTISIG` locking script requires the "m" (`2`), the public keys, and the "n" (`2`), you could write the following `scriptPubKey`: ``` -2 $address1 $address2 2 OP_CHECKMULTISIG +2 $pubkey1 $pubkey2 2 OP_CHECKMULTISIG ``` If this looks familiar, that's because it's the multisig that you deserialized in [§10.2: Building the Structure of P2SH](10_2_Building_the_Structure_of_P2SH.md). ``` @@ -48,20 +50,20 @@ The `scriptSig` for a standard multisig address must then submit the missing ope In order to spend a multisig UTXO, you run the `scriptSig` and `scriptPubKey` as follows: ``` -Script: 0 $signature1 $signature2 2 $address1 $address2 2 OP_CHECKMULTISIG +Script: 0 $signature1 $signature2 2 $pubkey1 $pubkey2 2 OP_CHECKMULTISIG Stack: [ ] ``` First, you place all the constants on the stack: ``` Script: OP_CHECKMULTISIG -Stack: [ 0 $signature1 $signature2 2 $address1 $address2 2 ] +Stack: [ 0 $signature1 $signature2 2 $pubkey1 $pubkey2 2 ] ``` Then, the `OP_CHECKMULTISIG` begins to run. First, the "2" is popped: ``` Running: OP_CHECKMULTISIG -Stack: [ 0 $signature1 $signature2 2 $address1 $address2 ] +Stack: [ 0 $signature1 $signature2 2 $pubkey1 $pubkey2 ] ``` -Then, the "2" tells `OP_CHECKMULTISIG `to pop two addresses: +Then, the "2" tells `OP_CHECKMULTISIG `to pop two public keys: ``` Running: OP_CHECKMULTISIG Stack: [ 0 $signature1 $signature2 2 ] @@ -81,7 +83,7 @@ Then, one more item is mistakenly popped: Running: OP_CHECKMULTISIG Stack: [ ] ``` -Then, `OP_CHECKMULTISIG` completes its operation by comparing the "m" signatures to the "n" addresses: +Then, `OP_CHECKMULTISIG` completes its operation by comparing the "m" signatures to the "n" public keys: ``` Script: Stack: [ True ] @@ -105,7 +107,7 @@ P2SH multisigs are the modern methodology for creating multisigs on the Blockcha To create a P2SH multisig, follow the standard steps for creating a P2SH locking script: -1. Serialize `2 $address1 $address2 2 OP_CHECKMULTISIG`. +1. Serialize `2 $pubkey1 $pubkey2 2 OP_CHECKMULTISIG`. 1. `` = "522102da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d1912102bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa352ae" 2. Save `` for future reference as the redeemScript. 1. `` = "522102da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d1912102bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa352ae" @@ -133,9 +135,9 @@ To unlock the P2SH multisig, first confirm the script: Then, run the multisig script: -1. Deserialize `` to `2 $address1 $address2 2 OP_CHECKMULTISIG`. +1. Deserialize `` to `2 $pubkey1 $pubkey2 2 OP_CHECKMULTISIG`. 2. Concatenate that with the earlier operands in the unlocking script, `0 $signature1 $signature2`. -3. Validate `0 $signature1 $signature2 2 $address1 $address2 2 OP_CHECKMULTISIG`. +3. Validate `0 $signature1 $signature2 2 $pubkey1 $pubkey2 2 OP_CHECKMULTISIG`. 4. Succeed if the operands fulfill the deserialized `redeemScript`. Now you know how the multisig transaction in [§6.1](06_1_Sending_a_Transaction_to_a_Multisig.md) was actually created, how it was validated for spending, and why that `redeemScript` was so important. diff --git a/11_1_Understanding_Timelock_Options.md b/11_1_Understanding_Timelock_Options.md index 978eaa59c..6de09d921 100644 --- a/11_1_Understanding_Timelock_Options.md +++ b/11_1_Understanding_Timelock_Options.md @@ -19,7 +19,7 @@ In more recent years, Bitcoin Core has expanded to allow the manipulation of tim _They Are Opcodes._ Because they're opcodes, CLTV and CSV can be used as part of more complex redemption conditions. Most often they're linked with the conditionals described in the next chapter. -_They Lock Outputs._ Because they're opcodes that are included in transactions as part of a `sigPubKey`, they just lock that single output. That means that the transactions are accepted onto the Bitcoin network and that the UTXOs used to fund those transactions are spent. There's no going back on a transaction timelocked with CLTV or CSV like there is with a bare `nLockTime`. Respending the resultant UTXO then requires that the timelock conditions be met. +_They Lock Outputs._ Because they're opcodes that are included in transactions as part of a `scriptPubKey`, they just lock that single output. That means that the transactions are accepted onto the Bitcoin network and that the UTXOs used to fund those transactions are spent. There's no going back on a transaction timelocked with CLTV or CSV like there is with a bare `nLockTime`. Respending the resultant UTXO then requires that the timelock conditions be met. Here's one catch for using timelocks: _They're one-way locks._ Timelocks are designed so that they unlock funds at a certain time. They cannot then relock a fund: once a timelocked fund is available to spend, it remains available to spend. diff --git a/11_3_Using_CSV_in_Scripts.md b/11_3_Using_CSV_in_Scripts.md index 745f9b99a..e0cfe5b69 100644 --- a/11_3_Using_CSV_in_Scripts.md +++ b/11_3_Using_CSV_in_Scripts.md @@ -12,19 +12,19 @@ A relative timelock is a lock that's placed on a specific input of a transaction Easy! -> :information_source: **NOTE — SEQUENCE:** This is the third use of the `nSequence` value in Bitcoin. Any `nSequence` value without the 32nd bit set (1<<31), so 0x00000001 to 0x7ffffffff, will be interpreted as a relative timelock if `nVersion ≥ 2` (which is the default starting in Bitcoin Core 0.14.0). You should be careful to ensure that relative timelocks don't conflict with the other two uses of `nSequence`, for signalling `nTimeLock` and RBF. `nTimeLock` usually sets a value of 0xffffffff-1, where a relative timelock is disallowed; and RBF usually sets a value of "1", where a relative timelock is irrelevent, because it defines a timelock of 1 block. +> :information_source: **NOTE — SEQUENCE:** This is the third use of the `nSequence` value in Bitcoin. Any `nSequence` value without the 32nd bit set (1<<31), so 0x00 00 00 01 to 0x7f ff ff ff, will be interpreted as a relative timelock if `nVersion ≥ 2` (which is the default starting in Bitcoin Core 0.14.0). You should be careful to ensure that relative timelocks don't conflict with the other two uses of `nSequence`, for signalling `nLockTime` and RBF. `nLockTime` usually sets a value of 0xff ff ff ff-1, where a relative timelock is disallowed; and RBF usually sets a value of "1", where a relative timelock is irrelevent, because it defines a timelock of 1 block. -> In general, remember: with a `nVersion` value of 2, a `nSequence` value of 0x00000001 to 0x7fffffff allows relative timelock, RBF, and `nTimeLock`; a `nSequence` value of 0x7fffffff to 0xffffffff-2 allows RBF and `nTimeLock`; a `nSequence` value of 0xffffffff-1 allows only `nTimeLock`; a `nSequence` value of 0xffffffff allows none; and `nVersion` can be set to 1 to disallow relative timelocks for any value of `nSequence`. Whew! +> In general, remember: with a `nVersion` value of 2, a `nSequence` value of 0x00000001 to 0x7ffffff allows relative timelock, RBF, and `nTimeLock`; a `nSequence` value of 0x7fffffff to 0xffffffff-2 allows RBF and `nTimeLock`; a `nSequence` value of 0xffffffff-1 allows only `nTimeLock`; a `nSequence` value of 0xffffffff allows none; and `nVersion` can be set to 1 to disallow relative timelocks for any value of `nSequence`. Whew! ### Create a CSV Relative Block Time -The format for using `nSequence` to represent relative time locks is defined in [BIP 68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki) and is slightly more complex than just inputting a number, like you did for `nTimeLock`. Instead, the BIP specifications breaks up the four byte number into three parts: +The format for using `nSequence` to represent relative time locks is defined in [BIP 68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki) and is slightly more complex than just inputting a number, like you did for `nLockTime`. Instead, the BIP specifications breaks up the four byte number into three parts: * The first two bytes are used to specify a relative locktime. * The 23rd bit is used to positively signal if the lock refers to a time rather than a blockheight. * The 32nd bit is used to positively signal if relative timelocks are deactivated. -With that said, the construction of a block-based relative timelock is still quite easy, because the two flagged bits are set to `0`, so you just set `nSequence` to a value between 1 and 0xffff (65535). The new transaction can be mined that number of blocks after the associated UTXO was mined. +With that said, the construction of a block-based relative timelock is still quite easy, because the two flagged bits are set to `0`, so you just set `nSequence` to a value between 1 and 0xff ff (65535). The new transaction can be mined that number of blocks after the associated UTXO was mined. ### Create a CSV Relative Time @@ -51,6 +51,8 @@ Finally, bitwise-or the 23rd bit into the hex value you created: ``` $ relativevalue=$(printf '%x\n' $((0x$hexvalue | 0x400000))) $ echo $relativevalue +4076a7 +$ printf "%d\n" "0x$relativevalue" 4224679 ``` If you convert that back you'll see that 4224679 = 10000000111011010100111. The 23rd digit is set to a "1"; meanwhile the first 2 bytes, 0111011010100111, convert to 76A7 in hex or 30375 in decimal. Multiply that by 512 and you get 15.55 million seconds, which indeed is 180 days. @@ -65,7 +67,7 @@ Except pretty much no one does this. The [BIP 68](https://github.com/bitcoin/bip | | Absolute Timelock | Relative Timelock | |:--------------------:|-------------------|-------------------| -| **Lock Transaction** | nTimeLock | nSequence | +| **Lock Transaction** | nLockTime | nSequence | | **Lock Output** | OP_CHECKLOCKTIMEVERIFY| OP_CHECKSEQUENCEVERIFY | ## Understand the CSV Opcode @@ -93,7 +95,7 @@ CSV has many of the same subtleties in usage as CLTV: * The `nVersion` field must be set to 2 or more. * The `nSequence` field must be set to less than 0x80000000. -* When CSV is run, there must be an operand on the stack that's between 0 and 0xf0000000-1. +* When CSV is run, there must be an operand on the stack that's between 0 and 0xf0 00 00 00-1. * Both the stack operand and `nSequence` must have the same value on the 23rd bit. * The `nSequence` must be greater than or equal to the stack operand. diff --git a/12_1_Using_Script_Conditionals.md b/12_1_Using_Script_Conditionals.md index 7634de7b9..6d564f1de 100644 --- a/12_1_Using_Script_Conditionals.md +++ b/12_1_Using_Script_Conditionals.md @@ -89,7 +89,7 @@ ELSE ENDIF ``` -Remember your reverse Polish notation! That `IF` statement if referring to the `OP_EQUAL` before it, not the `OP_CHECKSIG` after it! +Remember your reverse Polish notation! That `IF` statement is referring to the `OP_EQUAL` before it, not the `OP_CHECKSIG` after it! #### Run the True Branch @@ -136,7 +136,7 @@ Stack: [ True ] ``` #### Run the False Branch -Here's how it actally runs if unlocked with ` `: +Here's how it actually runs if unlocked with ` `: ``` Script: OP_DUP OP_HASH160 OP_EQUAL IF OP_CHECKSIG ELSE OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG ENDIF Stack: [ ] diff --git a/12_2_Using_Other_Script_Commands.md b/12_2_Using_Other_Script_Commands.md index af30e4e12..11c257ea7 100644 --- a/12_2_Using_Other_Script_Commands.md +++ b/12_2_Using_Other_Script_Commands.md @@ -78,7 +78,7 @@ Also see: `OP_CODESEPARATOR` (0xab), `OP_CHECKSIGVERIFY` (0xad), and `OP_CHECKMU ## Summary: Using Other Script Commands -Bitcoin Script includes a wide array of arithemetic, stack, and cryptographic opcodes. Most of these additional opcodes are probably not as common as the ones discussed in previous sections, but nonetheless they're available if they're just what you need to write your Script! +Bitcoin Script includes a wide array of arithmetic, stack, and cryptographic opcodes. Most of these additional opcodes are probably not as common as the ones discussed in previous sections, but nonetheless they're available if they're just what you need to write your Script! ## What's Next? diff --git a/13_0_Designing_Real_Bitcoin_Scripts.md b/13_0_Designing_Real_Bitcoin_Scripts.md index b24a4d148..17715b12c 100644 --- a/13_0_Designing_Real_Bitcoin_Scripts.md +++ b/13_0_Designing_Real_Bitcoin_Scripts.md @@ -1,6 +1,6 @@ # Chapter 13: Designing Real Bitcoin Scripts -Our Bitcoin Scripts to date have been largely theoretical examples, because we've still been putting together the puzzle pieces. Now, with the full Bitcoin Script repetoire in hand, we're ready to dig into several real-world Bitcoin Scripts and see how they work. +Our Bitcoin Scripts to date have been largely theoretical examples, because we've still been putting together the puzzle pieces. Now, with the full Bitcoin Script repertoire in hand, we're ready to dig into several real-world Bitcoin Scripts and see how they work. ## Objectives for This Chapter diff --git a/14_2_Changing_Your_Bitcoin_Hidden_Services.md b/14_2_Changing_Your_Bitcoin_Hidden_Services.md index b63a2ad9f..14ff3adc1 100644 --- a/14_2_Changing_Your_Bitcoin_Hidden_Services.md +++ b/14_2_Changing_Your_Bitcoin_Hidden_Services.md @@ -63,7 +63,7 @@ See [Bitcoin Onion Nodes](https://github.com/emmanuelrosa/bitcoin-onion-nodes) f Afterward, restart `tor` and `bitcoind`. -You should now be communicating exlusively on Tor. But, unless you are in a hostile state, this level of anonymity is probably not required. It also is not particularly recommended: you might greatly decrease your number of potential peers, inviting problems of censorship or even correlation. You may also see lag. And, this setup may give you a false sense of anonymity that really doesn't exist on the Bitcoin network. +You should now be communicating exclusively on Tor. But, unless you are in a hostile state, this level of anonymity is probably not required. It also is not particularly recommended: you might greatly decrease your number of potential peers, inviting problems of censorship or even correlation. You may also see lag. And, this setup may give you a false sense of anonymity that really doesn't exist on the Bitcoin network. > :warning: **WARNING:** This setup is untested! Use at your own risk! diff --git a/16_1_Accessing_Bitcoind_with_C.md b/16_1_Accessing_Bitcoind_with_C.md index eff28bc70..64bf5f3fc 100644 --- a/16_1_Accessing_Bitcoind_with_C.md +++ b/16_1_Accessing_Bitcoind_with_C.md @@ -6,8 +6,6 @@ You've already seen one alternative way to access the Bitcoind's RPC ports: `cur ## Set Up libbitcoinrpc -> :warning: **WARNING** It appears that `libbitcoinrpc` has been entirely abandoned. We have logged updating this to a new C library as an [issue](https://github.com/BlockchainCommons/Community/issues/140). In the meantime, the `libbitcoinrpc` library does not currently compile without intervention. As a result 16.1 and 16.2 is mainly viewable as pseudo-code that shows the process of integrating Bitcoin-Core with C. - To use `libbitcoinrpc`, you need to install a basic C setup and the dependent packages `libcurl`, `libjansson`, and `libuuid`. The following will do so on your Bitcoin Standup server (or any other Ubuntu server). ``` $ sudo apt-get install make gcc libcurl4-openssl-dev libjansson-dev uuid-dev @@ -26,8 +24,6 @@ $ sudo apt-get install git $ git clone https://github.com/BlockchainCommons/libbitcoinrpc.git ``` -> :warning: **WARNING** A change in the "signrawtransaction" RPC caused signing with `libbitcoinrpc` to segfault for Bitcoin 0.17 or higher. A [PR has been submitted](https://github.com/gitmarek/libbitcoinrpc/pull/1) to resolve the problem, but if it hasn't yet been merged, you can just make the one simple change in the source code to `src/bitcoinrpc_method.c` before compiling. - ### Compiling libbitcoinrpc Before you can compile and install the package, you'll probably need to adjust your `$PATH`, so that you can access `/sbin/ldconfig`: diff --git a/17_4_Using_PSBTs_in_Libwally.md b/17_4_Using_PSBTs_in_Libwally.md index 25be3c8fe..c889023b6 100644 --- a/17_4_Using_PSBTs_in_Libwally.md +++ b/17_4_Using_PSBTs_in_Libwally.md @@ -279,7 +279,7 @@ The creator role is tasked with creating a PSBT with at least one input. A PSBT is created with a simple use of `wally_psbt_init_alloc`, telling it how many inputs and outputs you will eventually add: ``` struct wally_psbt *psbt; - lw_response = wally_psbt_init_alloc(0,1,1,0,&psbt); + lw_response = wally_psbt_init_alloc(0,1,1,0,0,&psbt); ``` But what you have is not yet a legal PSBT, because of the lack of inputs. You can create those by creating a transaction and setting it as the global transaction in the PSBT, which updates all the inputs and outputs: ``` diff --git a/17_5_Using_Scripts_in_Libwally.md b/17_5_Using_Scripts_in_Libwally.md index dc350c075..55c007194 100644 --- a/17_5_Using_Scripts_in_Libwally.md +++ b/17_5_Using_Scripts_in_Libwally.md @@ -41,7 +41,7 @@ a9 / 14 / 3f58b4f7b14847a9083694b9b3b52a4cea2569ed / 87 ``` That's our old friend `OP_HASH160 3f58b4f7b14847a9083694b9b3b52a4cea2569ed OP_EQUAL`. -Basically, Libwally took your serialized redeem script, hashed it for you with SHA-256 and RIPEMD-160, and the applied the standard framing to turn it into a proper P2SH; You did similar work in [§10.2](10_2_Building_the_Structure_of_P2SH.md), but with an excess of shell commands. +Basically, Libwally took your serialized redeem script, hashed it for you with SHA-256 and RIPEMD-160, and then applied the standard framing to turn it into a proper P2SH; You did similar work in [§10.2](10_2_Building_the_Structure_of_P2SH.md), but with an excess of shell commands. In fact, you can double-check your work using the same commands from §10.2: ``` diff --git a/17_7_Integrating_Libwally_and_Bitcoin-CLI.md b/17_7_Integrating_Libwally_and_Bitcoin-CLI.md index 643a8b9cc..c92901f36 100644 --- a/17_7_Integrating_Libwally_and_Bitcoin-CLI.md +++ b/17_7_Integrating_Libwally_and_Bitcoin-CLI.md @@ -316,7 +316,6 @@ $ bitcoin-cli getaddressesbylabel "LibwallyWO" "purpose": "receive" } } -} ``` ## Summary: Integrating Libwally and Bitcoin-CLI diff --git a/18_1_Accessing_Bitcoind_with_Go.md b/18_1_Accessing_Bitcoind_with_Go.md index 2c10c7167..7759cc8fc 100644 --- a/18_1_Accessing_Bitcoind_with_Go.md +++ b/18_1_Accessing_Bitcoind_with_Go.md @@ -242,7 +242,7 @@ tb1qutkcj34pw0aq7n9wgp3ktmz780szlycwddfmza ### Decode an Address -Creating an address took a look extra work, in specifying the appropiate chain. Using an address also will because you'll have to decode it prior to use. +Creating an address took a little extra work, in specifying the appropriate chain. Using an address also will because you'll have to decode it prior to use. The means that you'll have to import both the ```"github.com/btcsuite/btcutil"``` and ```"github.com/btcsuite/btcd/chaincfg"``` libraries. * ```btcutil``` allows for a Bitcoin address to be decoded in a way that the`rpcclient` can understand. This is necessary when working with addresses in `rpcclient`. diff --git a/18_3_Accessing_Bitcoind_with_NodeJS.md b/18_3_Accessing_Bitcoind_with_NodeJS.md index 26216cc3c..dd3b9efd4 100644 --- a/18_3_Accessing_Bitcoind_with_NodeJS.md +++ b/18_3_Accessing_Bitcoind_with_NodeJS.md @@ -85,7 +85,7 @@ Obviously, your `user` and `pass` should again match what's in your `~/.bitcoin/ Using BCRPC, you can use the same RPC commands you would usually use via ```bitcoin-cli``` with your `RpcAgent`, except they need to be in camelCase. For example, ```getblockhash``` would be ```getBlockHash``` instead. -To print the newest block number, you just call `getBlockCount` thourgh your `RpcAgent`: +To print the newest block number, you just call `getBlockCount` through your `RpcAgent`: ``` agent.getBlockCount(function (err, blockCount) { diff --git a/18_4_Accessing_Bitcoind_with_Python.md b/18_4_Accessing_Bitcoind_with_Python.md index a5f8f259c..c35a35c8f 100644 --- a/18_4_Accessing_Bitcoind_with_Python.md +++ b/18_4_Accessing_Bitcoind_with_Python.md @@ -41,7 +41,7 @@ import logging ``` `pprint` will pretty print the `json` response from `bitcoind`. -`logging` will print out the call you make to `bitcoind` and `bitcoind`'s respose, which is useful when you make a bunch of calls together. If you don't want the excessive output in the terminal just comment out the `logging` block. +`logging` will print out the call you make to `bitcoind` and `bitcoind`'s response, which is useful when you make a bunch of calls together. If you don't want the excessive output in the terminal just comment out the `logging` block. ## Build Your Connection @@ -357,7 +357,7 @@ There are five steps: ### 1. Select UTXO & Set Transaction Details -In the folowing code snippet you first select the UTXO which we want to spend. Then you get its address, transaction id, and the vector index of the output. +In the following code snippet you first select the UTXO which we want to spend. Then you get its address, transaction id, and the vector index of the output. ```py utxos = rpc_client.listunspent() diff --git a/18_6_Accessing_Bitcoind_with_Swift.md b/18_6_Accessing_Bitcoind_with_Swift.md index bd662d1e1..c8078175d 100644 --- a/18_6_Accessing_Bitcoind_with_Swift.md +++ b/18_6_Accessing_Bitcoind_with_Swift.md @@ -56,7 +56,7 @@ rpcpassword=ebVCeSyyM0LurvgQyi0exWTqm4oU0rZU ``` ## Build Your Connection by Hand -At the time of this writing, there isn't an up-to-date, simple-to-use Bitcoin RPC Library that's specific for Swift, something that you can drop in and immediately start using. Thus, you're're going to do something you're never done before: build an RPC connection by hand. +At the time of this writing, there isn't an up-to-date, simple-to-use Bitcoin RPC Library that's specific for Swift, something that you can drop in and immediately start using. Thus, you're going to do something you're never done before: build an RPC connection by hand. ### Write the RPC Transmitter diff --git a/19_0_Understanding_Your_Lightning_Setup.md b/19_0_Understanding_Your_Lightning_Setup.md index ff1891354..0abbbc535 100644 --- a/19_0_Understanding_Your_Lightning_Setup.md +++ b/19_0_Understanding_Your_Lightning_Setup.md @@ -2,13 +2,13 @@ > :information_source: **NOTE:** This is a draft in progress, so that I can get some feedback from early reviewers. It is not yet ready for learning. -The previous chapter concluded our work with Bitcoin proper, through CLI, scripting, and programming languages. However, there are many other utilities within the Bitcoin ecosystem: this chapter and the next cover what may be the biggest and most important: the Lightning Network. Here you'll begin work with the `lightning-cli` command-line interface, understanding a c-lightning setup and its features, including some examples and basic configuration. +The previous chapter concluded our work with Bitcoin proper, through CLI, scripting, and programming languages. However, there are many other utilities within the Bitcoin ecosystem: this chapter and the next cover what may be the biggest and most important: the Lightning Network. Here you'll begin work with the `lightning-cli` command-line interface, understanding a core lightning setup and its features, including some examples and basic configuration. ## Objectives for This Chapter After working through this chapter, a developer will be able to: - * Assess that a c-lightning Node is Installed and Up-to-date + * Assess that a core lightning Node is Installed and Up-to-date * Perform Basic Lightning Wallet Commands * Create a LIghtning Channel @@ -20,7 +20,7 @@ Supporting objectives include the ability to: ## Table of Contents -* [Section One: Verifying Your c-lightning Setup](19_1_Verifying_Your_Lightning_Setup.md) -* [Section Two: Knowing Your c-lightning Setup](19_2_Knowing_Your_lightning_Setup.md) +* [Section One: Verifying Your core lightning Setup](19_1_Verifying_Your_Lightning_Setup.md) +* [Section Two: Knowing Your core lightning Setup](19_2_Knowing_Your_lightning_Setup.md) * [Interlude: Accessing a Second Lightning Node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md) * [Section Three: Creating a Lightning Channel](19_3_Setting_Up_a_Channel.md) diff --git a/19_1_Verifying_Your_Lightning_Setup.md b/19_1_Verifying_Your_Lightning_Setup.md index ab14bf4d6..9fb8c3ea7 100644 --- a/19_1_Verifying_Your_Lightning_Setup.md +++ b/19_1_Verifying_Your_Lightning_Setup.md @@ -1,14 +1,14 @@ -# 19.1: Creating a c-lightning Setup +# 19.1: Creating a core lightning Setup > :information_source: **NOTE:** This section has been recently added to the course and is an early draft that may still be awaiting review. Caveat reader. -In this section, you'll install and verify c-lightning, your utility for accessing the Lightning Network. +In this section, you'll install and verify core lightning, your utility for accessing the Lightning Network. > :book: ***What is the Lightning Network?*** The Lightning Network is a decentralized network that uses the smart contract functionality of the Bitcoin blockchain to enable instant payments across a network of participants. Lightning is built as a layer-2 protocol that interacts with Bitcoin to allow users to exchange their bitcoins "off-chain". > :book: ***What is a layer-2 protocol?*** Layer 2 refers to a secondary protocol built on top of the Bitcoin blockchain system. The main goal of these protocols is to solve the transaction speed and scaling difficulties that are present in Bitcoin: Bitcoin is not able to process thousands of transactions per second (TPS), so layer-2 protocols have been created to solve the blockchain scalability problem. These solutions are also known as "off-chain" scaling solutions. -## Install C-Lightning +## Install core Lightning If you used the [Bitcoin Standup Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts), you may have already installed Lightning at the beginning of this course. You can test this by seeing if `lightningd` is running: ``` @@ -27,15 +27,15 @@ standup 32072 0.0 0.0 6208 888 pts/0 S+ 15:50 0:00 grep -i lightni ``` If not, you'll need to install it now. Unfortunately, if you're using Debian you'll need to install it by hand, by compiling the source code — but it should still be pretty simple if you follow these instructions. If you happen to be on a standard Ubuntu system, instead try [Installing from Ubuntu ppa](#variant-install-from-ubuntu-ppa), and you can always attempt [Installing Pre-compiled Binaries](#variant-install-pre-compiled-binaries). -> :book: ***What is c-lightning?*** There are three different implementations of Lightning at present: c-lightning, LND, and Eclair. They should all be functionally compatible, based on the same [BOLT RFCs](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), but their implementation details may be different. We've chosen c-lightning as the basis of our course because it's also part of the same [Elements Project](https://github.com/ElementsProject) that also contains Libwally. +> :book: ***What is core lightning?*** There are three different implementations of Lightning at present: core lightning, LND, and Eclair. They should all be functionally compatible, based on the same [BOLT RFCs](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), but their implementation details may be different. We've chosen core lightning as the basis of our course because it's also part of the same [Elements Project](https://github.com/ElementsProject) that also contains Libwally. -### Compile the c-lightning Source Code +### Compile the core lightning Source Code Installing Lightning from source code should actually be pretty simple if you follow these instructions. You _probably_ want to do this on an unpruned node, as working with pruned nodes on Lightning may cause issues with installation and usage. If you set up your node way back at the start of this course to be pruned, you may wish to replace it with an unpruned node now. (If you're using testnet, you should be able to use the same type of machine as you did for your pruned node.) -> :warning: **WARNING:** You actually can run c-lightning on a pruned node. However, as the [Lightning repo](https://github.com/ElementsProject/lightning#pruning) notes, there may be issues. To make it work you have to ensure that your Lightning node is only ever trying to update info on blocks that your Bitcoin node has not pruned. To do so you must make sure (1) that your Bitcoin node is fully up to date before you start your Lightning node for the first time; and (2) that your Lightning node never falls too far behind your Bitcoin node (for a standard 550-block pruning, it can never be turned off for 4 or more days). So, you can do it, but it does introduce some danger, which isn't a good idea if you're running a production service. +> :warning: **WARNING:** You actually can run core lightning on a pruned node. However, as the [Lightning repo](https://github.com/ElementsProject/lightning#pruning) notes, there may be issues. To make it work you have to ensure that your Lightning node is only ever trying to update info on blocks that your Bitcoin node has not pruned. To do so you must make sure (1) that your Bitcoin node is fully up to date before you start your Lightning node for the first time; and (2) that your Lightning node never falls too far behind your Bitcoin node (for a standard 550-block pruning, it can never be turned off for 4 or more days). So, you can do it, but it does introduce some danger, which isn't a good idea if you're running a production service. With that, you're ready to install Lightning: @@ -95,7 +95,7 @@ A bitcoin lightning daemon (default values shown for network: testnet). You'll begin your exploration of the Lightning network with the `lightning-cli` command. However,`lightningd` _must_ be running to use `lightning-cli`, as `lightning-cli` sends JSON-RPC commands to the `lightningd` (all just as with `bitcoin-cli` and `bitcoind`). -If you installed `c-lightning` by hand, you'll now need to start it: +If you installed `core lightning` by hand, you'll now need to start it: ``` $ nohup lightningd --testnet & ``` @@ -228,12 +228,12 @@ bitcoin-cli -testnet getblock 0000000000000559febee77ab6e0be1b8d0bef0f971c7a4bee ## Create Aliases -We suggest creating some aliases to make it easier to use c-lightning. +We suggest creating some aliases to make it easier to use core lightning. You can do so by putting them in your `.bash_profile`. ``` cat >> ~/.bash_profile < :information_source: **NOTE:** This section has been recently added to the course and is an early draft that may still be awaiting review. Caveat reader. Before you begin accessing the Lightning Network, you should come to a better understanding of your setup. -## Know Your c-lightning Directory +## Know Your core lightning Directory -When using c-lightning, everything is kept in the `~/.lightning` directory. +When using core lightning, everything is kept in the `~/.lightning` directory. The main directory just contains directories for whichever networks are configured, in this case testnet: ``` diff --git a/19_2__Interlude_Accessing_a_Second_Lightning_Node.md b/19_2__Interlude_Accessing_a_Second_Lightning_Node.md index 8b03a7a3e..9bf997d7e 100644 --- a/19_2__Interlude_Accessing_a_Second_Lightning_Node.md +++ b/19_2__Interlude_Accessing_a_Second_Lightning_Node.md @@ -10,7 +10,7 @@ There are four ways to do so (the first three of which are possible for your fir If someone else already has a Lightning node on the network of your choice, just ask them for their ID. -If they are are running c-lightning, they just need to use the `getinfo` command: +If they are are running core lightning, they just need to use the `getinfo` command: ``` $ lightning-cli getinfo lightning-cli: WARNING: default network changing in 2020: please set network=testnet in config! @@ -50,9 +50,9 @@ lightning-cli: WARNING: default network changing in 2020: please set network=tes ``` They can then tell you their `id` (`03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687`). They will also need to tell you their IP address (`74.207.240.32`) and port (`9735`). -## Create a New c-lightning Node +## Create a New core lightning Node -However, for testing purposes, you probably want to have a second node under you own control. The easiest way to do so is to create a second c-lightning node on a new machine, using either Bitcoin Standup, per [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) or compiling it by hand, per [§19.1](19_1_Verifying_Your_Lightning_Setup.md). +However, for testing purposes, you probably want to have a second node under you own control. The easiest way to do so is to create a second core lightning node on a new machine, using either Bitcoin Standup, per [§2.1](02_1_Setting_Up_a_Bitcoin-Core_VPS_with_StackScript.md) or compiling it by hand, per [§19.1](19_1_Verifying_Your_Lightning_Setup.md). Once you have your node running, you can run `getinfo` to retrieve your information, as shown above. @@ -109,7 +109,7 @@ $ sudo cp $GOPATH/bin/lnd $GOPATH/bin/lncli /usr/bin ### Create an LND Config File -Unlike with c-lightning, you will need to create a default config file for LND. +Unlike with core lightning, you will need to create a default config file for LND. However first, you need to enable ZMQ on your Bitcoind, if you didn't already in [§16.3](16_3_Receiving_Bitcoind_Notifications_with_C.md). @@ -212,7 +212,7 @@ $ sudo systemctl start lnd ### Enable Remote Connections -Just as with c-lightning, you're going to need to make LND accessible to other nodes. Here's how to do so if you use `ufw`, as per the Bitcoin Standup setups: +Just as with core lightning, you're going to need to make LND accessible to other nodes. Here's how to do so if you use `ufw`, as per the Bitcoin Standup setups: ``` $ sudo ufw allow 9735 ``` @@ -316,10 +316,10 @@ However, that definitely won't be the case for your first interaction with the L ## Summary: Accessing a Second Lightning Node -You always need two Lightning nodes to form a channel. If you don't have someone else who is testing things out with you, you're going to need to create a second one, either using c-lightning or (as we will in our examples) LND. +You always need two Lightning nodes to form a channel. If you don't have someone else who is testing things out with you, you're going to need to create a second one, either using core lightning or (as we will in our examples) LND. ## What's Next? -Though you've possibly created an LND, c-lightning will remain the heart of our examples until we need to start using both of them, in [Chapter 19](19_0_Understanding_Your_Lightning_Setup.md). +Though you've possibly created an LND, core lightning will remain the heart of our examples until we need to start using both of them, in [Chapter 19](19_0_Understanding_Your_Lightning_Setup.md). Continue "Understanding Your Lightning Setup" with [§19.3: Setting Up_a_Channel](19_3_Setting_Up_a_Channel.md). diff --git a/19_3_Setting_Up_a_Channel.md b/19_3_Setting_Up_a_Channel.md index 19259aae1..b75f44f29 100644 --- a/19_3_Setting_Up_a_Channel.md +++ b/19_3_Setting_Up_a_Channel.md @@ -2,29 +2,29 @@ > :information_source: **NOTE:** This section has been recently added to the course and is an early draft that may still be awaiting review. Caveat reader. -You now understand the basics of your Lightning setup, and hopefully have either created or been given info on a second Lightning node. You're ready to create your first Lightning Network channel. Of course, you'll need to understand what is, and how it's created using c-lightning. +You now understand the basics of your Lightning setup, and hopefully have either created or been given info on a second Lightning node. You're ready to create your first Lightning Network channel. Of course, you'll need to understand what is, and how it's created using core lightning. > :book: ***What is a Lighting Channel?*** Simply, a lightning channel is a money tube that allows fast, cheap and private transfers of money without sending transactions to the blockchain. More technically a channel is a 2-of-2 multisignature on-chain Bitcoin transaction that establishes a trustless financial relationship between two people or two agents. A certain amount of money is deposited into the channel, when then mantains a local database with bitcoin balance for both parties, keeping track of how much money they each have from the initial amount. The two users can then exchange bitcoins through their Lightning channel without ever writing to the Bitcoin blockchain. Only when they want to close out their channel do they settle their bitcoins to the blockchain, based on the final division of coins. > :book: ***How do Lightning Channels Create a Lightning Network?*** Although a Lightning channel only allows payment between two users, channels can be connected together to form a network that allows payments between members that doesn't have a direct channel between them. This creates a network among multiple people built from pairwise connections. -In this section, we will continue using our c-lightning setup as our primary node. +In this section, we will continue using our core lightning setup as our primary node. ## Create a Channel Creating a Lightning channel requires the following steps: -* Fund your c-lightning wallet with some satoshis. +* Fund your core lightning wallet with some satoshis. * Connect to a remote node as a peer. * Open a channel. -### Fund Your c-lightning Wallet +### Fund Your core lightning Wallet -In order to move funds to a Lightning channel first requires funding your c-lightning wallet. +In order to move funds to a Lightning channel first requires funding your core lightning wallet. -> :book: ***What is a c-lightning wallet?*** C-lightning's standard implementation comes with a integrated Bitcoin wallet that allows you send and receive on-chain bitcoin transactions. This wallet will be used to create new channels. +> :book: ***What is a core lightning wallet?*** core lightning's standard implementation comes with a integrated Bitcoin wallet that allows you send and receive on-chain bitcoin transactions. This wallet will be used to create new channels. -The first thing you need to do is send some satoshis to your c-lightning wallet. You can create a new address using `lightning-cli newaddr` command. This generates a new address that can subsequently be used to fund channels managed by the c-lightning node. You can specify the type of address wanted; if not specified, the address generated will be a bech32. +The first thing you need to do is send some satoshis to your core lightning wallet. You can create a new address using `lightning-cli newaddr` command. This generates a new address that can subsequently be used to fund channels managed by the core lightning node. You can specify the type of address wanted; if not specified, the address generated will be a bech32. ``` $ lightning-cli --testnet newaddr @@ -74,15 +74,15 @@ Note that the value is listed in satoshis or microsatoshis, not Bitcoin! > :book: ***What are satoshis and msat?*** You already met satoshis way back in [§3.4](03_4_Receiving_a_Transaction.md). One satoshi is one hundred millionth of a bitcoin, so 300,000 satoshi = 0.003 BTC. A satoshi is the smallest unit of currency on the Bitcoin network. But, the Lightning network can go smaller, so 1,000 msat, or millisatoshis, equal one satoshi. That means that 1 msat is one hundred billionth of a bitcoin, and 300,000,000 msat = 0.003 BTC. -Now that you have funded your c-lightning wallet you will need information about a remote node to start creating channel process. +Now that you have funded your core lightning wallet you will need information about a remote node to start creating channel process. ### Connect to a Remote Node The next thing you need to do is connect your node to a peer. This is done with the `lightning-cli connect` command. Remember that if you want more information on this command, you should type `lightning-cli help connect`. -To connect your node to a remote peer you need its id, which represents the target node’s public key. As a convenience, `id` may be of the form `id@host` or `id@host:port`. You may have retrieved this with `lightning-cli getinfo` (on c-lightning) or `lncli --network=testnet getinfo` (on LND) as discussed in the [previous interlude](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). +To connect your node to a remote peer you need its id, which represents the target node’s public key. As a convenience, `id` may be of the form `id@host` or `id@host:port`. You may have retrieved this with `lightning-cli getinfo` (on core lightning) or `lncli --network=testnet getinfo` (on LND) as discussed in the [previous interlude](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). -We've selected the LND node, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, which is located at IP address `45.33.35.151`, which we're going to connect to from our c-lightning node: +We've selected the LND node, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, which is located at IP address `45.33.35.151`, which we're going to connect to from our core lightning node: ``` $ lightning-cli --network=testnet connect 032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543@45.33.35.151 diff --git a/20_1_Generate_a_Payment_Request.md b/20_1_Generate_a_Payment_Request.md index 8047bd0fb..3ae67a3e3 100644 --- a/20_1_Generate_a_Payment_Request.md +++ b/20_1_Generate_a_Payment_Request.md @@ -2,15 +2,15 @@ > :information_source: **NOTE:** This section has been recently added to the course and is an early draft that may still be awaiting review. Caveat reader. -This section describes how payments work on the Lightning Network, how to create a payment request (or _invoice_), and finally how to make sense of it. Issuing invoices depends on your having a second Lightning node, as described in [Accessing a Second Lightning Node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). These examples will use an LND node as their secondary node, to further demonstrate the possibilities of the Lightning Network. To differentiate between the nodes in these examples, the prompts will be shown as `c$` for the c-lightning node and `lnd$` as the LND node. If you want to reproduce this steps, you should [install your own secondary LND node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md#creating-a-new-lnd-node). +This section describes how payments work on the Lightning Network, how to create a payment request (or _invoice_), and finally how to make sense of it. Issuing invoices depends on your having a second Lightning node, as described in [Accessing a Second Lightning Node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). These examples will use an LND node as their secondary node, to further demonstrate the possibilities of the Lightning Network. To differentiate between the nodes in these examples, the prompts will be shown as `c$` for the core lightning node and `lnd$` as the LND node. If you want to reproduce this steps, you should [install your own secondary LND node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md#creating-a-new-lnd-node). > :book: ***What is an Invoice?** Almost all payments made on the Lightning Network require an invoice, which is nothing more than a **request for payment** made by the recipient of the money and sent by variety of means to the paying user. All payment requests are single use. Lightning invoices use bech32 encoding, which is already used by Segregated Witness for Bitcoin. ## Create an Invoice -To create a new invoice on c-lightning you would use the `lightning-cli --testnet invoice` command. +To create a new invoice on core lightning you would use the `lightning-cli --testnet invoice` command. -Here's how it would work with c-lightning, using arguments of an amount (in millisatoshis), a label, and a description. +Here's how it would work with core lightning, using arguments of an amount (in millisatoshis), a label, and a description. ``` c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for dinner" { @@ -21,7 +21,7 @@ c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for "warning_mpp_capacity": "The total incoming capacity is still insufficient even if the payer had MPP capability." } ``` -However, for this example we're going to instead generate an invoice on an LND node, and then pay it on the c-lightning node. This requires LND's slightly different `addinvoice` command. You can use `--amt` argument to indicate amount to be paid (in millisatoshis) and add a description using the `--memo` argument. +However, for this example we're going to instead generate an invoice on an LND node, and then pay it on the core lightning node. This requires LND's slightly different `addinvoice` command. You can use `--amt` argument to indicate amount to be paid (in millisatoshis) and add a description using the `--memo` argument. ``` lnd$ lncli -n testnet addinvoice --amt 10000 --memo "First LN Payment - Learning Bitcoin and Lightning from the Command line." @@ -63,7 +63,7 @@ The human readable part is `ln` + `tb` + `100u`. ### Read the Data Invoice Part -The rest of the invoice (`1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd`) contains a timestamp, specifically tagged data, and a signature. You obviously can't read it yourself, but you can ask c-lightning's `lightning-cli` to do so with the `decodepay` command: +The rest of the invoice (`1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd`) contains a timestamp, specifically tagged data, and a signature. You obviously can't read it yourself, but you can ask core lightning's `lightning-cli` to do so with the `decodepay` command: ``` c$ lightning-cli --testnet decodepay lntb100u1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd { diff --git a/20_3_Closing_a_Channel.md b/20_3_Closing_a_Channel.md index cda0cd39e..9361b796b 100644 --- a/20_3_Closing_a_Channel.md +++ b/20_3_Closing_a_Channel.md @@ -179,7 +179,7 @@ $ bitcoin-cli --named getrawtransaction txid=f68de52d80a1076e36c677ef640539c50e3 "blocktime": 1602713519 } ``` -The input of the transaction is `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, which was the funding transaction in [§19.3](19_3_Setting_Up_a_Channel.md). The transaction then has two outputs, one for the remote node and the other for the local c-lightning wallet. The output on index 0 corresponds to the remote node with a value of 0.00010012 BTC; and the output on index 1 corresponds to the local node with a value of 0.00089804 BTC. +The input of the transaction is `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, which was the funding transaction in [§19.3](19_3_Setting_Up_a_Channel.md). The transaction then has two outputs, one for the remote node and the other for the local core lightning wallet. The output on index 0 corresponds to the remote node with a value of 0.00010012 BTC; and the output on index 1 corresponds to the local node with a value of 0.00089804 BTC. Lightning will similarly show 89804 satoshis returned as a new UTXO in its wallet: ``` diff --git a/20_4_Lightning_Network_Review.md b/20_4_Lightning_Network_Review.md index c6f4d2792..46c956cc5 100644 --- a/20_4_Lightning_Network_Review.md +++ b/20_4_Lightning_Network_Review.md @@ -4,9 +4,9 @@ These two chapters have covered just a few of the most important activities with Lightning. There's lots more that can be done, and lots of variety possible. What follows are some pointers forward. -## Use c-lightning Plugins +## Use core lightning Plugins -c-lightning is a lightweight, highly customizable, and standard compliant implementation of the Lightning Network protocol. It extends it functionality using Plugins. Mainly, these are subprocesses that are initiated by the `lightningd` daemon and can interact with `lightningd` in a variety of ways: +core lightning is a lightweight, highly customizable, and standard compliant implementation of the Lightning Network protocol. It extends it functionality using Plugins. Mainly, these are subprocesses that are initiated by the `lightningd` daemon and can interact with `lightningd` in a variety of ways: * Command line options allow plugins to register their own command line arguments, which are then exposed through `lightningd`. * JSON-RPC command passthrough allows plugins to add their own commands to the JSON-RPC interface. @@ -19,19 +19,19 @@ The `lightningd` GitHub repo maintains a updated list of [plugins](https://githu ## Use Mobile Wallets -We currently know of two mobile lightning wallets that support the c-lightning implementation. +We currently know of two mobile lightning wallets that support the core lightning implementation. For iOS devices FullyNoded is an open-source iOS Bitcoin wallet that connects via Tor V3 authenticated service to your own full node. FullyNoded functionality is currently under active development and in early beta testing phase. * [FullyNoded](https://github.com/Fonta1n3/FullyNoded/blob/master/Docs/Lightning.md) -SparkWallet is a minimalistic wallet GUI for c-lightning, accessible over the web or through mobile and desktop apps for Android. +SparkWallet is a minimalistic wallet GUI for core lightning, accessible over the web or through mobile and desktop apps for Android. * [SparkWallet](https://github.com/shesek/spark-wallet) ## Use Different Lightning Implementations -c-lightning isn't your only option. Today there are three widely used implementations of the Lightning Network. All of them follow the [Basis of Lightning Technology (BOLT) documents](https://github.com/lightningnetwork/lightning-rfc), which describe a layer-2 protocol for off-chain bitcoin transfers. The specifications are currently a work-in-progress that is still being drafted. +core lightning isn't your only option. Today there are three widely used implementations of the Lightning Network. All of them follow the [Basis of Lightning Technology (BOLT) documents](https://github.com/lightningnetwork/lightning-rfc), which describe a layer-2 protocol for off-chain bitcoin transfers. The specifications are currently a work-in-progress that is still being drafted. | Name | Description | BitcoinStandup | Language | Repository | | ------------- | ------------- | :---: | ------------- | ------------- | diff --git a/A1_0_Understanding_Bitcoin_Standup.md b/A1_0_Understanding_Bitcoin_Standup.md index 722d00679..8c01b61db 100644 --- a/A1_0_Understanding_Bitcoin_Standup.md +++ b/A1_0_Understanding_Bitcoin_Standup.md @@ -12,7 +12,9 @@ Your host's timezone is stored in `/etc/timezone`, then an appropriate file from ## Step 3: Updating Debian -The `apt-get` package manager is used to bring your machine up to date and to install `gnupg`, the random-number generator `haveged`, and the uncomplicated firewall `ufw`. +The `apt-get` package manager is used to bring your machine up to date and to install `gnupg`, `git`, the random-number generators `haveged` and `xxd`, and the uncomplicated firewall `ufw`. + +The `apt-get` commands are run with `-y`, which should force all questions to be answered "yes", and allow the script to be run without interaction (e.g., as a StackScript). That failed with the Debian 13 update, with some questions going unanswered and locking up the script, so the `-o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold"` options were added to say, "We're really serious, no questions!" Your machine is setup to automatically stay up to date with `echo "unattended-upgrades unattended-upgrades/enable_auto_updates boolean true" | debconf-set-selections`. @@ -20,7 +22,7 @@ Your machine is setup to automatically stay up to date with `echo "unattended-up A `standup` user is created, which will be used for your Bitcoin applications. It also has `sudo` permissions, allowing you to take privileged actions with this account. -If you supplied an SSH key, it will allow you access to this account (otherwise, you must use the password you created in setup). +If you supplied a Standup SSH key, it will allow you access to this account (otherwise, you must use the password you created in setup). If you supplied an IP address, `ssh` access will be limited to that address, per `/etc/hosts.allow`. diff --git a/Bitcoin_Command_line.epub b/Bitcoin_Command_line.epub new file mode 100644 index 000000000..f0120b39d Binary files /dev/null and b/Bitcoin_Command_line.epub differ diff --git a/CLA-signed/CLA.misterdelle.95471FFA0C364BB13618FE956197E47B27E98909.asc b/CLA-signed/CLA.misterdelle.95471FFA0C364BB13618FE956197E47B27E98909.asc new file mode 100644 index 000000000..d15122abb --- /dev/null +++ b/CLA-signed/CLA.misterdelle.95471FFA0C364BB13618FE956197E47B27E98909.asc @@ -0,0 +1,65 @@ +-----BEGIN PGP SIGNED MESSAGE----- +Hash: SHA512 + +# Contributor License Agreement + +Version 1.0 + +Name: Andrea Delle Chiaie + +E-Mail: andrea@dellechiaie.it + +Legal Jurisdiction: Wyoming, United States of America + +Project: https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line + +Date: `01/24/2026` + +## Purpose + +This agreement gives Blockchain Commons, LLC the permission it needs in order to accept my contributions into its open software project and to manage the intellectual property in that project over time. + +## License + +I hereby license Blockchain Commons, LLC to: + +1. do anything with my contributions that would otherwise infringe my copyright in them + +2. do anything with my contributions that would otherwise infringe patents that I can or become able to license + +3. sublicense these rights to others on any terms they like + +## Reliability + +I understand that Blockchain Commons will rely on this license. I may not revoke this license. + +## Awareness + +I promise that I am familiar with legal rules, like ["work made for hire" rules](http://worksmadeforhire.com), that can give employers and clients ownership of intellectual property in work that I do. I am also aware that legal agreements I might sign, like confidential information and invention assignment agreements, will usually give ownership of intellectual property in my work to employers, clients, and companies that I found. If someone else owns intellectual property in my work, I need their permission to license it. + +## Copyright Guarantee + +I promise not to offer contributions to the project that contain copyrighted work that I do not have legally binding permission to contribute under these terms. When I offer a contribution with permission, I promise to document in the contribution who owns copyright in what work, and how they gave permission to contribute it. If I later become aware that one of my contributions may have copyrighted work of others that I did not have permission to contribute, I will notify Blockchain Commons, in confidence, immediately. + +## Patent Guarantee + +I promise not to offer contributions to the project that I know infringe patents of others that I do not have permission to contribute under these terms. + +## Open Source Guarantee + +I promise not to offer contributions that contain or depend on the work of others, unless that work is available under a license that [Blue Oak Council rates bronze or better](https://blueoakconcil.org/list), such as the MIT License, two- or three-clause BSD License, the Apache License Version 2.0, or the Blue Oak Model License 1.0.0. When I offer a contribution containing or depending on others' work, I promise to document in the contribution who licenses that work, along with copies of their license terms. + +## Disclaimers + +***As far as the law allows, my contributions come as is, without any warranty or condition. Other than under [Copyright Guarantee](#copyright-guarantee), [Patent Guarantee](#patent-guarantee), or [Open Source Guarantee](#open-source-guarantee), I will not be liable to anyone for any damages related to my contributions or this contributor license agreement, under any kind of legal claim.*** + +- --- + +To sign this Contributor License Agreement, fill in `$name`, `$email`, and `$date` above. Then sign using GPG using the following command `gpg --armor --clearsign --output ./CLA-signed/CLA.YOURGITHUBNAME.YOURGPGFINGERPRINT.asc CLA.md`, then either submit your signed Contributor License Agreement to this repo as a GPG signed Pull Request or email it to [ChristopherA@BlockchainCommons.com](mailto:ChristopherA@BlockchainCommons.com). +-----BEGIN PGP SIGNATURE----- + +iHUEARYKAB0WIQSVRx/6DDZLsTYY/pVhl+R7J+mJCQUCaXTzFwAKCRBhl+R7J+mJ +CT+8AQCbdoyHki5m1WBwnbKzdhl1eBoKvoNuHD+Z7O4n/4NVewEAkumn2wsfXHSP +rtK7r/72KXxVag7G3k0rWVFhORH8Fgw= +=tBny +-----END PGP SIGNATURE----- diff --git a/README.md b/README.md index 8a3ce99ce..7566ce500 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,20 @@ -# Learning Bitcoin from the Command Line 2.2.0 +# Learning Bitcoin from the Command Line 2.2.2 ### _by Christopher Allen and Shannon Appelcline_ ![](https://www.blockchaincommons.com/images/projects/lbtc-screen.png) -Learning Bitcoin from the Command Line is a tutorial for working with Bitcoin (and Lightning) that teaches direct interaction with the servers themselves, as the most robust and secure way to begin cryptocurrency work. +--- + +***In 2026, Learning Bitcoin from the Command Line is being brought up to date with a new 3.0 edition. If you want to see the work in progress, visit our [`lbtcftcl-v3.0` branch](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/tree/lbtcftcl-v3.0), which is already much more up-to-date than v2.2.2. But be aware it is being worked on through the end of the year, and so will not be complete or entirely coherent before then.*** -> NOTE: This is a draft in progress, so that I can get some feedback from early reviewers. It is not yet ready for use. +--- + +Learning Bitcoin from the Command Line is a tutorial for working with Bitcoin (and Lightning) that teaches direct interaction with the servers themselves, as the most robust and secure way to begin cryptocurrency work. _This tutorial assumes that you have some minimal background of how to use the command line interface. If not, there are many tutorials available, and I have one for Mac users at https://github.com/ChristopherA/intro-mac-command-line._ +_You may also be interested in our newer [Learning FROST from the Command Line course](https://learningfrost.blockchaincommons.com/)._ + ## Translations * [Portuguese](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/tree/portuguese-translation/pt/README.md) — v2.0.1 translation @@ -134,8 +140,8 @@ If you'd like to make your own translation, please see [Contributing](https://gi **Status:** Finished. * [19.0: Understanding Your Lightning Setup](19_0_Understanding_Your_Lightning_Setup.md) - * [19.1: Verifying Your c-lightning Setup](19_1_Verifying_Your_Lightning_Setup.md) - * [19.2: Knowing Your c-lightning Setup](19_2_Knowing_Your_lightning_Setup.md) + * [19.1: Verifying Your core lightning Setup](19_1_Verifying_Your_Lightning_Setup.md) + * [19.2: Knowing Your core lightning Setup](19_2_Knowing_Your_lightning_Setup.md) * [Interlude: Accessing a Second Lightning Node](19_2__Interlude_Accessing_a_Second_Lightning_Node.md) * [19.3: Creating a Lightning Channel](19_3_Setting_Up_a_Channel.md) * [20.0: Using Lightning](20_0_Using_Lightning.md) @@ -155,11 +161,18 @@ If you'd like to make your own translation, please see [Contributing](https://gi ## Status - Beta -v2.1.0 of **Learning Bitcoin from the Command Line** is feature complete and has undergone full editing and integration. It is ready for learning +v2.2.2 of **Learning Bitcoin from the Command Line** is feature complete and has undergone full editing and integration. It is ready for learning. However, it is out-of-date, focused on Bitcoin Core 22.0. We are currently working on [v3.0](TODO-30.md) of the course, for release toward the end of 2026. If you'd like to support work of that sort, become a [GitHub Sponsor](https://github.com/sponsors/BlockchainCommons) or support us at our [BTCPay Server](https://btcpay.blockchaincommons.com/), and let us know that **Learning Bitcoin** was the reason why. -We are also tentatively considering what we could include in a [v3.0](TODO-30.md) of the course. If you'd like to support work of that sort, become a [GitHub Sponsor](https://github.com/sponsors/BlockchainCommons) or support us at our [BTCPay Server](https://btcpay.blockchaincommons.com/), and let us know that **Learning Bitcoin** was the reason why. ### Version History +#### 2.2.2 (January 22, 2026) + +* Updated §2.1 and Appendix 1 to accomodate recent updates to [Bitcoin-Standup-Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts) as well as changes to the Linode interface. + +#### 2.2.1 (January 15, 2026) + +* Incorporation of PRs and Issues, to close out previous iteration of course, in prep for big 3.0 update. + #### 2.2.0 (November 17, 2021) * [Portuguese translation](https://github.com/BlockchainCommons/Learning-Bitcoin-from-the-Command-Line/tree/master/pt) diff --git a/TODO-20.md b/TODO-20.md deleted file mode 100644 index fdc8847e5..000000000 --- a/TODO-20.md +++ /dev/null @@ -1,137 +0,0 @@ -# Todo List for v2.0 of Learning Bitcoin - -This is a list of potential (or planned) TODO items for "Learning Bitcoin from the Command Line". Many are drawn from issues found at the previous locale of this repo. - -**Updating Work Begun:** 6/10 -**Updating Work Done:** 10/27 -**Pending Issues:** Third-party edit of whole course - -Please also see [TODO-30.md](the v3.0 TODO) for the next iteration of the course. - -## 1. Integrate with Bitcoin-Standup - -Replace our current scripts with Bitcoin Standup (which was based on those scripts) - -1. Fix Verification errors in Bitcoin Standup Scripts **6/10** - * Fix IPADDR error in Bitcoin Standup Scripts **6/10** -2. Upgrade Bitcoin Standup Scripts to Debian 10 **6/16** -3. Upgrade Bitcoin Standup Scripts to Bitcoin 0.20 **6/16** -4. Ensure Bitcoin Standup covers everything else in previous scripts **6/16** -5. Rewrite the StackScript chapter **6/16** -6. Rewrite the "by-hand" chapter to match Bitcoin Standup **7/27** - * Write New Appendix 1 **7/27** - * Revise All Chapter Ordering for Cut §2.1 **7/27** -7. Reintroduce aliases after setup **6/19** -8. Figure out what to do about the old `btcblock` on testnet, where there seems to be no CLI way to determine blockheight. **No Known Solution on Testnet** - -## 2. Upgrade to 0.20 - -9. Walk through chapters 1-6, making sure all commands work with Bitcoin Core 0.20 (and changing them if not). Redo the output of all examples. **6/19**, **6/23**, **6/30** - * Edit Chapter 0 **6/19** - * Edit Chapter 1 **6/19** - * Re-edit Chapter 2 **6/19** - * Edit & Check Chapter 3 **6/19** - * Edit & Check Chapter 4 **6/23** - * Double-check fee calculator in 4.2I with a more complex example **6/19** - * Integrate older Curl Interlude **6/19** - * Edit & Check Chapter 5 **6/23** - * Edit & Check Chapter 6 **6/30** - * Update for change in importaddress **7/7** - -## 3. Add BTCDEB Support - -10. Update Scripting & Integrate `btcdeb` - * Edit & Integrate Chapter 9 **7/15** - * Fix P2PKH Example **7/15** - * Write P2WPKH Chapter **7/15** - * Edit & Integrate Chapter 10 **7/15, 7/21** - * Write P2WSH Chapter **7/21** - * Edit & Integrate Chapter 11 **7/21** - * Edit & Integrate Chapter 12 **7/21** - * Edit & Integrate Chapter 13 **7/21** - * Turn off verbose info on btcdeb? - * Get sigs working right on btcdeb? - -## 4. Add New Concepts - -Add and document the following new concepts: - -11. Add SegWit Transactions. The majority of Bitcoin transactions now use this signing methodology, so it needs to be fully explained and incorporated, alongside its newer bech32 addresses. **6/23** - * Add definitions of Segwit and bech32 addresses to 3.3 **6/23** - * Do we still have to use "bitcoin-cli getnewaddress "" legacy" on CLI? If not, run back through chapters that use legacy in their examples, starting in 3.3 **Gonna leave it for now. A future version might shift to P2SH-SegWit as default.** - * Integrate discussions of SegWit into early parts of chapter 4. **6/23** - * Write chapter 4.6 **6/23** -12. Add PSBT. Partially Signed Bitcoin Transactions are a powerful new interchange format that should be fully included in our discussions of multi-sigs and escrows (which instead fell back on older methodologies in v1.0). **7/2**, **7/7**, **7/10** - * Research PSBTs **7/2** - * Update Outlines **7/2** - * Write 7.1: Creating a PSBT **7/7** - * Create Illustrations for 7.1 **7/7** - * Write 7.2: Using a PSBT **7/7**, **7/10** - * Multisigs **7/7** - * Redo with correct math **7/10** - * Fund Pooling **7/10** - * CoinJoins **7/10** - -13. Add Wallet Updates. **6/30**, **7/2**, **7/7** - * Bitcoin Descriptors **6/30** - * Show what a SegWit descriptor looks like **7/2** - * Show what a multi-sig descriptor looks like **7/2** - * Revise based on comments **7/7** - * Key Ordering (sortedmulti) **7/2** **Partially Supported in 0.20** -14. Consider HWI. **7/14** - * Write 7.3: Using HWI **7/14** - * Edit All of Chapter 6-8 **7/14** -15. Consider splitting up Chapter 6 (definitely if we get an HWI chapter) - * Break apart Chapter 6 **7/2** - * Rewrite all section links in early chapters (1-5, 6, 8) **7/7** - * Update Script Chapters **7/15** - * Update Tor Chapter **7/22** - * Update Programming Chapters - -## 5. Finish Later Chapters - -16. Edit & Integrate Tor Chapter. **7/22** -17. Edit & Integrate all "C" work **8/5** - **8/26** - * Edit & Update Chapter 15 **8/5** - * Write the Libwally section **8/5** - **8/26** - * 16.1: Intro **8/5** - * 16.2: BIP39 **8/11** - * 16.3: BIP32 **8/11** - * 16.4: PSBTs **8/12** - * 16.5: Scripts **8/12** - * 16.6: Other Functions **8/18** - * 16.7: Integration **8/25**, **8/26** -18. Edit & Integrate all "Other Languages" work **9/1**-**9/30** - * Edit 17.1: Go **9/1** - * Edit 17.2: Java **9/2** - * Edit 17.3: NodeJS **9/2** - * Edit 17.4: Python **9/8** - * Edit 17.5: Rust **9/8** - * Write 17.6: Swift **9/29** - * Setup Swift Environment **9/9**, **9/15** - * Document Swift Environment **9/23** - * Do Basic RPC Commands **9/29** - * Look at Wallets **9/29** - * Create Transaction **9/29** - * First edit of Swift **9/30** - * Edit All of 17 **9/30** - * Finalize Naming of Src **9/30** - * Full Edit of 17.1-17.6 **9/30** -19. Edit & Integrate Appendices work **7/27**, **8/4** - * Edit & Integrate A2: Compiling **7/27** - * Edit & Integrate A3: RegTest **8/4** -20. Edit & Integrate Lightning Chapters **10/13**, **10/14** - * Figure out how/if to set up a pruned c-lightning **10/13** - -## 6. Finalize Book - -21. Take out warnings for all old chapters **10/20** -22. Add new first chapter, indicating places to start for people of different levels **10/20** -23. Add other Bitcoin standup options to Ch. 2 **10/27** -24. Move an coding appendices (e.g., JQ interlude) to src code directory **10/20** -25. Write letter about new edition **10/27** -26. Write tweetstorm **10/27** - -## 7. Additional Support - -27. Full edit of book (intern?) diff --git a/TODO-30.md b/TODO-30.md index 034148af8..3d12e301a 100644 --- a/TODO-30.md +++ b/TODO-30.md @@ -7,11 +7,16 @@ The following TODO items are intended for a 3.0 version of Learning Bitcoin from The following updates involve updates or the creation of new chapters, but their additions are generally bounded and known. 1. General Update: Consider replacing testnet with signet +1. Big changes to defaults + * Signet + * SEGWIT + * Descriptor Wallets 1. New Interlude: Creating QR Codes (after 3.3) * New Subsection: Creating a QR * New Subsection: Creating a Quick Connect QR 1. Revise Section: Understanding the Descriptor (3.5) * New Content: Descriptor Wallets + * Possibly also remove legacy wallets (3.3) and replace them entire with descriptors * New Content: Complex Descriptors * Consider: Breaking into Two Sections 1. New Interlude: Creating Animated QR Codes (after 7.1) diff --git a/es/01_0_Introduccion.md b/es/01_0_Introduccion.md index aacb863cd..d78030103 100644 --- a/es/01_0_Introduccion.md +++ b/es/01_0_Introduccion.md @@ -6,7 +6,7 @@ La forma en que realizamos pagos por bienes y servicios ha cambiado drásticamen Estos riesgos de centralización fueron algunos de los principales catalizadores detrás de la creación de las criptomonedas, el primero y más exitoso proyecto es Bitcoin. Bitcoin ofrece seudoanonimato; dificulta la correlación de transacciones y hace que la censura por parte de entidades individuales sea casi imposible. Estas ventajas la han convertido en una de las monedas de más rápido crecimiento en el mundo. Ese crecimiento, a su vez, ha convertido a Bitcoin en una empresa en marcha entre empresarios y desarrolladores, ansiosos por crear nuevos servicios para la comunidad de Bitcoin. -Si eres uno de esos emprendedores o desarrolladores, este curso es para ti, porque se trata de aprender a programar Bitcoin. Es un curso introductorio que explica todos los matices y características de Bitcoin a medida que avanza. También toma un rumbo muy específico, al ofrecer lecciones sobre cómo trabajar directamente con Bitcoin Core y con el servidor c-lightning usando sus interfaces RPC. +Si eres uno de esos emprendedores o desarrolladores, este curso es para ti, porque se trata de aprender a programar Bitcoin. Es un curso introductorio que explica todos los matices y características de Bitcoin a medida que avanza. También toma un rumbo muy específico, al ofrecer lecciones sobre cómo trabajar directamente con Bitcoin Core y con el servidor core lightning usando sus interfaces RPC. ¿Por qué no utilizar algunas de las bibliotecas más completas que se encuentran en varios lenguajes de programación? ¿Por qué no crear el tuyo propio desde cero? Porque empezar a trabajar con criptomonedas puede ser peligroso. No hay redes de seguridad. Si accidentalmente paga de más en sus tarifas o pierde una llave de firma o crea una transacción no válida o comete una cantidad de errores potenciales, entonces sus monedas desaparecerán para siempre. Gran parte de esa responsabilidad, por supuesto, recaerá en usted como programador de criptomonedas, aunque puede minimizarse el riesgo trabajando con las interfaces de criptomonedas más sólidas, seguras y probadas, las creadas por los propios equipos de programación de criptomonedas: bitcoind y lightningd. @@ -56,7 +56,7 @@ Obviamente está trabajando en este curso porque está interesado en Bitcoin. Ad * Utilice el [área de discusión](https://github.com/BlockchainCommons/Community/discussions) de nuestra comunidad para hablar sobre carreras y habilidades. Blockchain Commons ocasionalmente ofrece pasantías, como se explica en nuestro repositorio de la comunidad. * Conviértase en un [patrocinador](https://github.com/sponsors/BlockchainCommons) si encuentra útil este curso o si desea ayudar a educar a la próxima generación de programadores de blockchain. -# ¿Que Sigue? +# ¿Qué Sigue? Si desea una introducción básica a Bitcoin, criptografía de clave pública, ECC, blockchains y Lightning, lea el interludio [Introduciendo Bitcoin.](01_1_Introduciendo_Bitcoin.md) diff --git a/es/01_1_Introduciendo_Bitcoin.md b/es/01_1_Introduciendo_Bitcoin.md index 1bdde4740..d913152b6 100644 --- a/es/01_1_Introduciendo_Bitcoin.md +++ b/es/01_1_Introduciendo_Bitcoin.md @@ -8,19 +8,19 @@ Bitcoin es un sistema programático que permite la transferencia de la moneda bi Obviamente, Bitcoin es el corazón de este libro, pero también es el creador de muchos otros sistemas, incluidas otras blockchains y Lightning, que se detallan en este tutorial al igual que muchas otras criptomonedas como Ethereum y Litecoin que no son mencionadas. -**_Cómo se transfieren las monedas?_** La moneda Bitcoin no son monedas físicas. En cambio, son una serie interminable de reasignaciones de propiedad. Cuando una persona envía monedas a otra, esa transferencia se almacena como una transacción. Es la transacción la que realmente registra la propiedad del dinero y no un token local en la billetera del propietario o en su máquina. +**_¿Cómo se transfieren las monedas?_** La moneda Bitcoin no son monedas físicas. En cambio, son una serie interminable de reasignaciones de propiedad. Cuando una persona envía monedas a otra, esa transferencia se almacena como una transacción. Es la transacción la que realmente registra la propiedad del dinero y no un token local en la billetera del propietario o en su máquina. -**_A quién puede enviarle monedas?_** La gran mayoría de las transacciones de bitcoin implican el envío de monedas a personas individuales (o al menos a direcciones de bitcoin individuales). Sin embargo, se pueden utilizar metodologías más complejas para enviar monedas a grupos de personas o scripts. Estas diversas metodologías tienen nombres como P2PKH, multisig y P2SH. +**_¿A quién puede enviarle monedas?_** La gran mayoría de las transacciones de bitcoin implican el envío de monedas a personas individuales (o al menos a direcciones de bitcoin individuales). Sin embargo, se pueden utilizar metodologías más complejas para enviar monedas a grupos de personas o scripts. Estas diversas metodologías tienen nombres como P2PKH, multisig y P2SH. -**_Cómo se almacenan las transacciones?_** Las transacciones se combinan en bloques de datos más grandes, que luego se escriben en el libro mayor de la cadena de bloques. Un bloque se construye de tal manera que no se puede reemplazar o reescribir una vez que se han construido varios bloques sobre él (después). Esto es lo que hace que la moneda bitcoin sean irreprochable: el libro de contabilidad global descentralizado donde todo se registra es efectivamente una base de datos permanente e inmutable. +**_¿Cómo se almacenan las transacciones?_** Las transacciones se combinan en bloques de datos más grandes, que luego se escriben en el libro mayor de la cadena de bloques. Un bloque se construye de tal manera que no se puede reemplazar o reescribir una vez que se han construido varios bloques sobre él (después). Esto es lo que hace que la moneda bitcoin sean irreprochable: el libro de contabilidad global descentralizado donde todo se registra es efectivamente una base de datos permanente e inmutable. Sin embargo, el proceso de construcción de estos bloques es estocástico: es algo aleatorio, por lo que nunca puede estar seguro de que una transacción se colocará en un bloque específico. También puede haber cambios en los bloques si son muy recientes, pero solo si son muy recientes. Por lo tanto las cosas se vuelven realmente irreprochables (así como permanentes e inmutables) después de un poco de tiempo. -**_Cómo se protegen las transacciones?_** Los fondos contenidos en una transacción de Bitcoin están bloqueados con un rompecabezas criptográfico. Estos acertijos están diseñados para que los pueda resolver fácilmente la persona a la que se enviaron los fondos. Esto se hace utilizando el poder de la criptografía de clave pública. Técnicamente, una transacción está protegida por una firma que demuestra que usted es el propietario de la clave pública a la que se envió una transacción: esta prueba de propiedad es el rompecabezas que se está resolviendo. +**_¿Cómo se protegen las transacciones?_** Los fondos contenidos en una transacción de Bitcoin están bloqueados con un rompecabezas criptográfico. Estos acertijos están diseñados para que los pueda resolver fácilmente la persona a la que se enviaron los fondos. Esto se hace utilizando el poder de la criptografía de clave pública. Técnicamente, una transacción está protegida por una firma que demuestra que usted es el propietario de la clave pública a la que se envió una transacción: esta prueba de propiedad es el rompecabezas que se está resolviendo. Los fondos están aún más protegidos mediante el uso de hashes. Las claves públicas no se almacenan realmente en la cadena de bloques hasta que se gastan los fondos: son los hashes de clave pública los que se guardan. Esto significa que incluso si apareciera la computadora cuántica, las transacciones de Bitcoin permanecerían protegidas por este segundo nivel de criptografía. -**_Cómo se crean las transacciones?_** El corazón de cada transacción de Bitcoin es un lenguaje de secuencias de comandos similar a FORTH que se utiliza para bloquear la transacción. Para volver a gastar el dinero, el destinatario debe proporcionar información específica al guión que demuestra que es el destinatario previsto. +**_¿Cómo se crean las transacciones?_** El corazón de cada transacción de Bitcoin es un lenguaje de secuencias de comandos similar a FORTH que se utiliza para bloquear la transacción. Para volver a gastar el dinero, el destinatario debe proporcionar información específica al guión que demuestra que es el destinatario previsto. Sin embargo, estos scripts de Bitcoin son el nivel más bajo de funcionalidad de Bitcoin. Gran parte del trabajo de Bitcoin se realiza a través del demonio de Bitcoin llamado `bitcoind`, que es controlado mediante el uso de comandos RPC. Mucha gente envía esos comandos RPC a través del programa `bitcoin-cli`, que proporciona una interfaz aún más simple. Los no programadores ni siquiera se preocupan por estas minucias, sino que utilizan carteras programadas con interfaces más simples. @@ -34,13 +34,13 @@ La criptografía de clave pública es un sistema matemático para proteger los d Es importante para Bitcoin (y para la mayoría de los sistemas blockchain) porque es la base de gran parte de la criptografía que protege los fondos de criptomonedas. Una transacción de Bitcoin generalmente se envía a una dirección que es hash de una clave pública. Luego, el destinatario puede recuperar el dinero revelando tanto la clave pública como la clave privada. -**_Qué es una clave pública?_** Una clave pública es la clave que se entrega a otras personas. En un sistema típico de clave pública, un usuario genera una clave pública y una clave privada, luego le da la clave pública a todos y cada uno. Esos destinatarios podrán cifrar información con la clave pública, pero no podrán descifrar con la misma clave pública debido a la asimetría del par de claves. +**_¿Qué es una clave pública?_** Una clave pública es la clave que se entrega a otras personas. En un sistema típico de clave pública, un usuario genera una clave pública y una clave privada, luego le da la clave pública a todos y cada uno. Esos destinatarios podrán cifrar información con la clave pública, pero no podrán descifrar con la misma clave pública debido a la asimetría del par de claves. -**_Qué es una clave privada?_** Una clave privada está vinculada a una clave pública en un par de claves. En un sistema típico de clave pública, un usuario mantiene segura su clave privada y la usa para descifrar los mensajes que fueron encriptados con su clave pública antes de enviárselos. +**_¿Qué es una clave privada?_** Una clave privada está vinculada a una clave pública en un par de claves. En un sistema típico de clave pública, un usuario mantiene segura su clave privada y la usa para descifrar los mensajes que fueron encriptados con su clave pública antes de enviárselos. -**_Qué es una firma?_** Un mensaje (o más comúnmente, un hash de un mensaje) se puede firmar con una clave privada, creando una firma. Cualquiera que tenga la clave pública correspondiente puede validar la firma, lo que verifica que el firmante sea el propietario de la clave privada asociada con la clave pública en cuestión. SegWit es un formato específico para almacenar una firma en la red Bitcoin que encontraremos más adelante. +**_¿Qué es una firma?_** Un mensaje (o más comúnmente, un hash de un mensaje) se puede firmar con una clave privada, creando una firma. Cualquiera que tenga la clave pública correspondiente puede validar la firma, lo que verifica que el firmante sea el propietario de la clave privada asociada con la clave pública en cuestión. SegWit es un formato específico para almacenar una firma en la red Bitcoin que encontraremos más adelante. -**_Qué es una función hash?_** Una función hash es un algoritmo que se utiliza con frecuencia en conjunto con la criptografía. Es una forma de asignar una gran cantidad arbitraria de datos a una pequeña cantidad fija de datos. Las funciones hash que se utilizan en criptografía son unidireccionales y resistentes a colisiones, lo que significa que un hash se puede vincular de manera confiable a los datos originales, pero los datos originales no se pueden regenerar a partir del hash. Por tanto, los hashes permiten la transmisión de pequeñas cantidades de datos para representar grandes cantidades de datos, que pueden ser importantes para la eficiencia y los requisitos de almacenamiento. +**_¿Qué es una función hash?_** Una función hash es un algoritmo que se utiliza con frecuencia en conjunto con la criptografía. Es una forma de asignar una gran cantidad arbitraria de datos a una pequeña cantidad fija de datos. Las funciones hash que se utilizan en criptografía son unidireccionales y resistentes a colisiones, lo que significa que un hash se puede vincular de manera confiable a los datos originales, pero los datos originales no se pueden regenerar a partir del hash. Por tanto, los hashes permiten la transmisión de pequeñas cantidades de datos para representar grandes cantidades de datos, que pueden ser importantes para la eficiencia y los requisitos de almacenamiento. Bitcoin aprovecha la capacidad de un hash para disfrazar los datos originales, lo que permite ocultar la clave pública real de un usuario, lo que hace que las transacciones sean resistentes a la computación cuántica. @@ -54,19 +54,19 @@ ECC significa Criptografía de Curva Elíptica. Es una rama específica de la cr ECC no recibe mucha atención en este tutorial. Esto se debe a que este tutorial trata sobre la integración con los servidores Bitcoin Core y Lightning, que ya se han ocupado de la criptografía por el lector. De hecho, la intención de este tutorial es que no tenga que preocuparse en absoluto por la criptografía, porque eso es algo de lo que realmente quiere que se ocupen los expertos. -**_Qué es una curva elíptica?_** Una curva elíptica es una curva geométrica que toma la forma `y``2` = `x``3`` + ax + b`. Se elige una curva elíptica específica seleccionando valores específicos de `a` y `b`. Luego, la curva debe examinarse cuidadosamente para determinar si funciona bien para la criptografía. Por ejemplo, la curva secp256k1 utilizada por Bitcoin se define como `a=0` y `b=7`. +**_¿Qué es una curva elíptica?_** Una curva elíptica es una curva geométrica que toma la forma `y``2` = `x``3`` + ax + b`. Se elige una curva elíptica específica seleccionando valores específicos de `a` y `b`. Luego, la curva debe examinarse cuidadosamente para determinar si funciona bien para la criptografía. Por ejemplo, la curva secp256k1 utilizada por Bitcoin se define como `a=0` y `b=7`. Cualquier línea que cruce una curva elíptica lo hará en 1 o 3 puntos ... y esa es la base de la criptografía de curva elíptica. -**_Qué son los campos finitos?_** Un campo finito es un conjunto finito de números, donde toda suma, resta, multiplicación y división se define de modo que da como resultado otros números también en el mismo campo finito. Una forma sencilla de crear un campo finito es mediante el uso de una función de módulo. +**_¿Qué son los campos finitos?_** Un campo finito es un conjunto finito de números, donde toda suma, resta, multiplicación y división se define de modo que da como resultado otros números también en el mismo campo finito. Una forma sencilla de crear un campo finito es mediante el uso de una función de módulo. -**_Cómo se define una curva elíptica sobre un campo finito?_** Una curva elíptica definida sobre un campo finito tiene todos los puntos de su curva extraídos de un campo finito específico. Esto toma la forma: `y``2` `% field-size = (x``3`` + ax + b) % field-size` El campo finito usado para secp256k1 es `2``256`` - 2``32`` - 2``9`` - 2``8`` - 2``7`` - 2``6`` - 2``4`` - 1`. +**_¿Cómo se define una curva elíptica sobre un campo finito?_** Una curva elíptica definida sobre un campo finito tiene todos los puntos de su curva extraídos de un campo finito específico. Esto toma la forma: `y``2` `% field-size = (x``3`` + ax + b) % field-size` El campo finito usado para secp256k1 es `2``256`` - 2``32`` - 2``9`` - 2``8`` - 2``7`` - 2``6`` - 2``4`` - 1`. -**_Cómo se utilizan las curvas elípticas en criptografía?_** En la criptografía de curva elíptica, un usuario selecciona un número muy grande (256 bits) como clave privada. Luego agrega un punto base establecido en la curva a sí misma tantas veces. (En secp256k1, el punto base es `G = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8`, que antepone las dos partes de la tupla con un `04` para decir que el punto de datos está en forma descomprimida. Si prefiere una definición geométrica recta, es el punto "0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199") El número resultante es la clave pública. Luego, se pueden usar varias fórmulas matemáticas para demostrar la propiedad de la clave pública, dada la clave privada. Al igual que con cualquier función criptográfica, esta es una trampilla: es fácil pasar de la clave privada a la clave pública y general es imposible pasar de la clave pública a la clave privada. +**_¿Cómo se utilizan las curvas elípticas en criptografía?_** En la criptografía de curva elíptica, un usuario selecciona un número muy grande (256 bits) como clave privada. Luego agrega un punto base establecido en la curva a sí misma tantas veces. (En secp256k1, el punto base es `G = 04 79BE667E F9DCBBAC 55A06295 CE870B07 029BFCDB 2DCE28D9 59F2815B 16F81798 483ADA77 26A3C465 5DA4FBFC 0E1108A8 FD17B448 A6855419 9C47D08F FB10D4B8`, que antepone las dos partes de la tupla con un `04` para decir que el punto de datos está en forma descomprimida. Si prefiere una definición geométrica recta, es el punto "0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798,0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199") El número resultante es la clave pública. Luego, se pueden usar varias fórmulas matemáticas para demostrar la propiedad de la clave pública, dada la clave privada. Al igual que con cualquier función criptográfica, esta es una trampilla: es fácil pasar de la clave privada a la clave pública y general es imposible pasar de la clave pública a la clave privada. Esta metodología en particular también explica por qué se utilizan campos finitos en curvas elípticas: asegura que la clave privada no crecerá demasiado. Tenga en cuenta que el campo finito para secp256k1 es un poco más pequeño que 256 bits, lo que significa que todas las claves públicas tendrán 256 bits de longitud, al igual que las claves privadas. -**_Cuáles son las ventajas de ECC?_** La principal ventaja de ECC es que permite la misma seguridad que la criptografía clásica de clave pública con una clave mucho más pequeña. Una clave pública de curva elíptica de 256 bits corresponde a una clave pública tradicional (RSA) de 3072 bits. +**_¿Cuáles son las ventajas de ECC?_** La principal ventaja de ECC es que permite la misma seguridad que la criptografía clásica de clave pública con una clave mucho más pequeña. Una clave pública de curva elíptica de 256 bits corresponde a una clave pública tradicional (RSA) de 3072 bits. ### ECC - En resumen @@ -78,15 +78,15 @@ Blockchain es la generalización de la metodología utilizada por Bitcoin para c Aunque debe comprender los conceptos básicos de cómo funciona una cadena de bloques para comprender cómo funcionan las transacciones en Bitcoin, no necesitará ir más allá. Debido a que las cadenas de bloques se han convertido en una amplia categoría de tecnología, es probable que esos conceptos básicos sean aplicables a muchos otros proyectos en este creciente sector tecnológico. Sin embargo, los comandos de programación específicos aprendidos en este libro no lo serán, ya que son bastante específicos de Bitcoin (y Lightning). -**_Por qué se llama cadena?_** Cada bloque de la cadena de bloques almacena un hash del bloque anterior. Esto une el último bloque actual hasta el "bloque génesis" original a través de una cadena ininterrumpida. Es una forma de crear un orden absoluto entre datos posiblemente conflictivos. Esto también proporciona la seguridad de la cadena de bloques, porque cada bloque se apila sobre uno antiguo, lo que dificulta la recreación del bloque antiguo debido a los algoritmos de prueba de trabajo utilizados en la creación de bloques. Una vez que se han construido varios bloques sobre un bloque de la cadena, es esencialmente irreversible. +**_¿Por qué se llama cadena?_** Cada bloque de la cadena de bloques almacena un hash del bloque anterior. Esto une el último bloque actual hasta el "bloque génesis" original a través de una cadena ininterrumpida. Es una forma de crear un orden absoluto entre datos posiblemente conflictivos. Esto también proporciona la seguridad de la cadena de bloques, porque cada bloque se apila sobre uno antiguo, lo que dificulta la recreación del bloque antiguo debido a los algoritmos de prueba de trabajo utilizados en la creación de bloques. Una vez que se han construido varios bloques sobre un bloque de la cadena, es esencialmente irreversible. -**_Qué es una bifurcación (fork)?_** De forma ocasional se crean dos bloques aproximadamente al mismo tiempo. Esto crea temporalmente una bifurcación de un bloque, donde cualquiera de los bloques actuales podría ser el "real". De vez en cuando, una bifurcación puede expandirse para convertirse en dos bloques, tres bloques o incluso cuatro bloques de largo, pero rápidamente se determina que un lado de la bifurcación es el real y el otro queda "huérfano". Esto es parte del proceso estocástico de creación de bloques y demuestra por qué se deben construir varios bloques encima de un bloque antes de que pueda considerarse verdaderamente confiable y no repudiable. +**_¿Qué es una bifurcación (fork)?_** De forma ocasional se crean dos bloques aproximadamente al mismo tiempo. Esto crea temporalmente una bifurcación de un bloque, donde cualquiera de los bloques actuales podría ser el "real". De vez en cuando, una bifurcación puede expandirse para convertirse en dos bloques, tres bloques o incluso cuatro bloques de largo, pero rápidamente se determina que un lado de la bifurcación es el real y el otro queda "huérfano". Esto es parte del proceso estocástico de creación de bloques y demuestra por qué se deben construir varios bloques encima de un bloque antes de que pueda considerarse verdaderamente confiable y no repudiable. ### Blockchain - En resumen Una forma de pensar en blockchain es: una serie enlazada de bloques de datos inmutables que se remontan al pasado. Otra forma es: una serie enlazada de bloques para ordenar datos de forma absoluta que podrían estar en conflicto. -## Blockchain es adecuado para mí? +## ¿Blockchain es adecuado para mí? Si desea realizar transacciones con bitcoins, obviamente Bitcoin es adecuado para usted. Sin embargo, de manera más generalizada, blockchain se ha convertido en una palabra de moda popular a pesar de que no es una fórmula mágica para todos los problemas técnicos. Dicho esto, hay muchas situaciones específicas en las que blockchain es una tecnología superior. @@ -110,7 +110,7 @@ Las cadenas de bloques probablemente no serán útiles si: * Se requiere secreto: * por ejemplo: la información debe ser secreta. * por ejemplo: las transacciones deben ser secretas. - * por ejemplo: los Transactores deben ser secretos. + * por ejemplo: los participantes en la transacción deben ser secretos. * A menos que: Se considere, analice y pruebe cuidadosamente una metodología para el secreto criptográfico. * Los usuarios necesitan la finalidad instantánea de la transacción. * por ejemplo: en menos de 10 minutos en una red similar a Bitcoin, en menos de 2.5 minutos en una red similar a Litecoin, en menos de 15 segundos en una red similar a Ethereum @@ -123,17 +123,17 @@ Lightning es un protocolo de capa 2 que interactúa con Bitcoin para permitir a Lightning Network también es el enfoque secundario de este tutorial. Aunque se trata principalmente de interactuar directamente con Bitcoin (y el `bitcoind`), presta algo de atención a Lightning porque es una tecnología de próxima aparición que probablemente se convierta en una alternativa popular a Bitcoin en un futuro próximo. Este libro adopta el mismo enfoque para Lightning que para Bitcoin: enseña cómo interactuar directamente con un demonio Lightning confiable desde la línea de comandos. -A diferencia de Bitcoin, en realidad existen varias variantes de Lightning. Este tutorial utiliza la implementación de [c-lightning](https://github.com/ElementsProject/lightning) compatible con el estándar como su servidor Lightning de confianza. +A diferencia de Bitcoin, en realidad existen varias variantes de Lightning. Este tutorial utiliza la implementación de [core lightning](https://github.com/ElementsProject/lightning) compatible con el estándar como su servidor Lightning de confianza. -**_Qué es un protocolo de capa 2?_** Un protocolo de Bitcoin de capa 2 funciona sobre Bitcoin. En este caso, Lightning funciona sobre Bitcoin, interactuando con este a través de contratos inteligentes. +**_¿Qué es un protocolo de capa 2?_** Un protocolo de Bitcoin de capa 2 funciona sobre Bitcoin. En este caso, Lightning funciona sobre Bitcoin, interactuando con este a través de contratos inteligentes. -**_Qué es un canal Lightning?_** Un canal Lightning es una conexión entre dos usuarios de Lightning. Cada uno de los usuarios bloquea una cierta cantidad de bitcoins en la cadena de bloques de Bitcoin utilizando una transacción multi-firma por ambos. Los dos usuarios pueden intercambiar bitcoins a través de su canal Lightning sin tener que escribir en la cadena de bloques de Bitcoin. Solo cuando quieren cerrar su canal liquidan sus bitcoins, según la división final de monedas. +**_¿Qué es un canal Lightning?_** Un canal Lightning es una conexión entre dos usuarios de Lightning. Cada uno de los usuarios bloquea una cierta cantidad de bitcoins en la cadena de bloques de Bitcoin utilizando una transacción multi-firma por ambos. Los dos usuarios pueden intercambiar bitcoins a través de su canal Lightning sin tener que escribir en la cadena de bloques de Bitcoin. Solo cuando quieren cerrar su canal liquidan sus bitcoins, según la división final de monedas. -**_Qué es la red Lightning?_** Al juntar varios canales se crea la red Lightning. Esto permite que dos usuarios que no han creado un canal entre ellos intercambien bitcoins usando Lightning: el protocolo forma una cadena de Canales entre los dos usuarios, luego intercambia las monedas a través de la cadena mediante transacciones de tiempo bloqueado. +**_¿Qué es la red Lightning?_** Al juntar varios canales se crea la red Lightning. Esto permite que dos usuarios que no han creado un canal entre ellos intercambien bitcoins usando Lightning: el protocolo forma una cadena de Canales entre los dos usuarios, luego intercambia las monedas a través de la cadena mediante transacciones de tiempo bloqueado. -**_Cuáles son las ventajas de Lightning?_** Lightning permite transacciones más rápidas con tarifas más bajas. Esto crea la posibilidad real de micropagos financiados con bitcoins. También ofrece una mejor privacidad, ya que está fuera de la cadena y solo se escribe el primer y último estado de la transacción en el libro de contabilidad inmutable de Bitcoin. +**_¿Cuáles son las ventajas de Lightning?_** Lightning permite transacciones más rápidas con tarifas más bajas. Esto crea la posibilidad real de micropagos financiados con bitcoins. También ofrece una mejor privacidad, ya que está fuera de la cadena y solo se escribe el primer y último estado de la transacción en el libro de contabilidad inmutable de Bitcoin. -**_Cuáles son las desventajas de la red Lightning?_** Lightning sigue siendo una tecnología muy nueva y no se ha probado tan a fondo como Bitcoin. No se trata solo de la implementación tecnológica, sino también el diseño en sí mismo se puede actuar de alguna manera inesperada. +**_¿Cuáles son las desventajas de la red Lightning?_** Lightning sigue siendo una tecnología muy nueva y no se ha probado tan a fondo como Bitcoin. No se trata solo de la implementación tecnológica, sino también el diseño en sí mismo se puede actuar de alguna manera inesperada. ### Lightning - en resumen @@ -143,6 +143,6 @@ Una forma de pensar en Lightning es: una forma de realizar transacciones con bit Bitcoin es un sistema peer-to-peer que permite la transferencia de fondos a través de transacciones bloqueadas con acertijos. Estos acertijos dependen de la criptografía de curva elíptica de clave pública. Cuando generalizas las ideas detrás de Bitcoin, surge la cadena de bloques, una tecnología que actualmente está creciendo e innovando. Cuando expande las ideas detrás de Bitcoin, obtiene protocolos de capa 2 como Lightning, que expanden el potencial de la moneda. -## Que Sigue? +## ¿Qué Sigue? Continúe a través de la "Preparación para Bitcoin" con el [Capítulo dos: Configuración de un VPS Bitcoin-Core](02_0_Configurando_un_Bitcoin-Core_VPS.md) diff --git a/es/02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md b/es/02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md index 7aafd9ab7..b333e290f 100644 --- a/es/02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md +++ b/es/02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md @@ -191,7 +191,7 @@ Aunque la imagen predeterminada de Debian 10 que estamos usando para su VPS ha s Su instalación de Bitcoin VPS es mínima y casi no permite ninguna comunicación. Esto se hace a través del sencillo firewall (`ufw`), que bloquea todo excepto las conexiones SSH. También es posible una seguridad adicional para sus puertos RPC, gracias a los servicios ocultos instalados por Tor. -**Ajustando UFW.** ¡Probablemente debería dejar UFW en su etapa superprotegida! No debería utilizar una máquina Bitcoin para otros servicios, ¡porque todos aumentan su vulnerabilidad! Si decide lo contrario, hay varias [guías de UFW](https://www.digitalocean.com/community/tutorials/ufw-essentials-common-firewall-rules-and-commands) que le permitirán agregar servicios. Como se anuncia, no es complicado. Por ejemplo, agregar servicios de correo solo requeriría abrir el puerto de correo: `sudo ufw allow 25`. Pero en general no debería eso. +**Ajustando UFW.** ¡Probablemente debería dejar UFW en su etapa superprotegida! No debería utilizar una máquina Bitcoin para otros servicios, ¡porque todos aumentan su vulnerabilidad! Si decide lo contrario, hay varias [guías de UFW](https://www.digitalocean.com/community/tutorials/ufw-essentials-common-firewall-rules-and-commands) que le permitirán agregar servicios. Como se anuncia, no es complicado. Por ejemplo, agregar servicios de correo solo requeriría abrir el puerto de correo: `sudo ufw allow 25`. Pero en general no debería hacer eso. **Ajuste de Tor.** Es posible que desee proteger mejor servicios tales como SSH. Consulte el [Capítulo 14: Usando Tor](14_0_Usando_Tor.md) para obtener más información sobre Tor. @@ -216,7 +216,7 @@ Si por alguna razón quisiera cambiar esto (_no lo sugerimos_), puede hacer esto echo "unattended-upgrades unattended-upgrades/enable_auto_updates boolean false" | debconf-set-selections ``` -_Si desea saber más sobre lo que hace el stackscript de Bitcoin Standup, consulte el [Apéndice I: Entendiendo Bitcoin Standup] (A1_0_Entendiendo_la_Configuracion_Inicial_de_Bitcoin.md) ._ +_Si desea saber más sobre lo que hace el stackscript de Bitcoin Standup, consulte el [Apéndice I: Entendiendo Bitcoin Standup](A1_0_Entendiendo_Bitcoin_Standup.md) ._ ## Jugando con Bitcoin @@ -240,7 +240,7 @@ Aún así, podría ser hora de algunos expresos más. Pero muy pronto, su sistem La creación de un VPS de Bitcoin-Core con los scripts Standup hizo que todo el proceso fuera rápido, simple y (con suerte) sin contratiempos. -## ¿Que sigue? +## ¿Qué sigue? Tiene algunas opciones para lo que sigue: diff --git a/es/02_2_Configurando_Bitcoin_Core_Otros.md b/es/02_2_Configurando_Bitcoin_Core_Otros.md index 7e0a8c7db..e6632ff69 100644 --- a/es/02_2_Configurando_Bitcoin_Core_Otros.md +++ b/es/02_2_Configurando_Bitcoin_Core_Otros.md @@ -17,7 +17,7 @@ paso a paso para configurar Bitcoin-Core con Amazon Web Services (AWS). * *[Configuración de un nodo Bitcoin en una Raspberry Pi 3](https://medium.com/@meeDamian/bitcoin-full-node-on-rbp3-revised-88bb7c8ef1d1).* Damian Mee explica cómo configurar una Nodo completo de forma sencilla en una Raspberry Pi 3. -## ¿Que sigue? +## ¿Qué sigue? A menos que desee volver a una de las otras metodologías para crear un nodo Bitcoin-Core, debe: diff --git a/es/03_2_Conociendo_Su_Configuracion_Bitcoin.md b/es/03_2_Conociendo_Su_Configuracion_Bitcoin.md index 7b6cf437b..ca38a33eb 100644 --- a/es/03_2_Conociendo_Su_Configuracion_Bitcoin.md +++ b/es/03_2_Conociendo_Su_Configuracion_Bitcoin.md @@ -310,6 +310,6 @@ No dude en hacer referencia a cualquiera de estos y utilizar el comando "bitcoin El directorio `~/.bitcoin` contiene todos sus archivos, mientras que `bitcoin-cli help` se puede usar con una variedad de comandos informativos para obtener más información sobre cómo funcionan su configuración y Bitcoin. -## ¿Que sigue? +## ¿Qué sigue? Continúe "Entendiendo su configuracion de Bitcoin" en [§3.3: Configurando su billetera](03_3_Configurando_Su_Billetera.md). diff --git a/es/03_3_Configurando_Su_Billetera.md b/es/03_3_Configurando_Su_Billetera.md index 96f994e45..246dd119e 100644 --- a/es/03_3_Configurando_Su_Billetera.md +++ b/es/03_3_Configurando_Su_Billetera.md @@ -4,7 +4,7 @@ Ahora está listo para comenzar a trabajar con Bitcoin. Para empezar, deberá cr ## Crear una billetera -> :warning: **VERSION WARNING:** Las versiones más recientes de Bitcoin Core, a partir de la v0.21.0, ya no crearán automáticamente una billetera predeterminada al inicio. Por lo tanto, deberá crear uno manualmente. Pero si está ejecutando una versión anterior de Bitcoin Core, ya se ha creado una nueva billetera para usted, en cuyo caso puede pasar a [Crear una dirección] (#crear-una-dirección). +> :warning: **VERSION WARNING:** Las versiones más recientes de Bitcoin Core, a partir de la v0.21.0, ya no crearán automáticamente una billetera predeterminada al inicio. Por lo tanto, deberá crear uno manualmente. Pero si está ejecutando una versión anterior de Bitcoin Core, ya se ha creado una nueva billetera para usted, en cuyo caso puede pasar a [Crear una dirección](#crear-una-dirección). Lo primero que debe hacer es crear una nueva billetera, lo que se puede hacer con el comando `bitcoin-cli createwallet`. Al crear una nueva billetera, creará su par de claves pública-privada. Su clave pública es la fuente a partir de la cual se crearán sus direcciones, y su clave privada es la que le permitirá gastar los fondos que reciba en sus direcciones. Bitcoin Core guardará automáticamente esa información en un archivo `wallet.dat` en su directorio `~/.bitcoin/testnet3/wallets`. @@ -65,7 +65,7 @@ Sería un "2" para una dirección P2SH o un "tb1" para una dirección Bech32. Toma nota de la dirección. Deberá entregárselo a quien le envíe los fondos. -> :book: ***¿Qué es una dirección Bitcoin?*** Una dirección de Bitcoin es, literalmente, donde recibe dinero. Es como una dirección de correo electrónico, pero para fondos. Técnicamente, es una clave pública, aunque diferentes esquemas de direcciones lo ajustan de diferentes maneras. Sin embargo, a diferencia de una dirección de correo electrónico, una dirección de Bitcoin debe considerarse de un solo uso: úsela para recibir fondos solo una vez . Cuando desee recibir fondos de otra persona o en otro momento, genere una nueva dirección. Esto se sugiere en gran parte para mejorar su privacidad. Toda la cadena de bloques es inmutable, lo que significa que los exploradores pueden observar largas cadenas de transacciones a lo largo del tiempo, lo que hace posible determinar estadísticamente quiénes son usted y sus contactos, sin importar cuán cuidadoso sea. Sin embargo, si sigue reutilizando la misma dirección, esto se vuelve aún más fácil. +> :book: ***¿Qué es una dirección Bitcoin?*** Una dirección de Bitcoin es, literalmente, donde recibe dinero. Es como una dirección de correo electrónico, pero para fondos. Técnicamente, es una clave pública, aunque diferentes esquemas de direcciones lo ajustan de diferentes maneras. Sin embargo, a diferencia de una dirección de correo electrónico, una dirección de Bitcoin debe considerarse de un solo uso: úsela para recibir fondos solo una vez. Cuando desee recibir fondos de otra persona o en otro momento, genere una nueva dirección. Esto se sugiere en gran parte para mejorar su privacidad. Toda la cadena de bloques es inmutable, lo que significa que los exploradores pueden observar largas cadenas de transacciones a lo largo del tiempo, lo que hace posible determinar estadísticamente quiénes son usted y sus contactos, sin importar cuán cuidadoso sea. Sin embargo, si sigue reutilizando la misma dirección, esto se vuelve aún más fácil. Con una sola dirección en la mano, puede pasar directamente a la siguiente sección y comenzar a recibir fondos. Sin embargo, antes de llegar allí, discutiremos brevemente los otros tipos de direcciones que encontrará en el futuro y hablaremos sobre algunos otros comandos de billetera que quizás desee usar en el futuro. @@ -169,6 +169,6 @@ _Ha estado escribiendo esa dirección Bitcoin que generó muchas veces, mientras Necesita crear una dirección para recibir fondos. Su dirección se almacena en una billetera, de la que puede hacer una copia de seguridad. También puede hacer mucho más con una dirección, como descargar su clave privada o usarla para firmar mensajes. Pero realmente, crear esa dirección es _todo_ lo que necesita hacer para recibir fondos de Bitcoin. -## ¿Que sigue? +## ¿Qué sigue? Aléjese de "Comprendiendo la configuración de Bitcoin" con [Interludio: Usando variables de la linea de comandos](03_3_Interludio_Usando_Variables_Linea_Comando.md) diff --git a/es/03_3_Interludio_Usando_Variables_Linea_Comando.md b/es/03_3_Interludio_Usando_Variables_Linea_Comando.md index 708600497..0a0859ccf 100644 --- a/es/03_3_Interludio_Usando_Variables_Linea_Comando.md +++ b/es/03_3_Interludio_Usando_Variables_Linea_Comando.md @@ -41,6 +41,6 @@ El resto de este tutorial utilizará este estilo de guardar información en vari Las variables de la línea de comandos se pueden usar para contener cadenas largas de Bitcoin, lo que minimiza las posibilidades de errores. -## ¿Que sigue? +## ¿Qué sigue? Continúe "Comprendiendo la configuración de Bitcoin" en [§3.4: Recibiendo una transacción](03_4_Recibiendo_una_Transaccion.md). diff --git a/es/03_5_Entendiendo_El_Descriptor.md b/es/03_5_Entendiendo_El_Descriptor.md index 9da5c1deb..ff5a4a913 100644 --- a/es/03_5_Entendiendo_El_Descriptor.md +++ b/es/03_5_Entendiendo_El_Descriptor.md @@ -20,7 +20,7 @@ El movimiento de direcciones entre carteras se solía centrar en `xpub` y` xprv` El hecho de que pueda tener una "secuencia completa de claves secundarias ..." revela el hecho de que "xpub" y "xprv" no son claves estándar como hemos estado hablando hasta ahora. En cambio, son claves jerárquicas que se pueden usar para crear familias completas de claves, basadas en la idea de HD Wallets. -> :libro: ***¿Qué es una billetera HD?*** La mayoría de las billeteras modernas se basan en [BIP32: billeteras deterministas jerárquicas](https://github.com/bitcoin/bips/blob/master/bip-0032. mediawiki). Se trata de un diseño jerárquico en el que se puede utilizar una única semilla para generar una secuencia completa de claves. La billetera completa se puede restaurar a partir de esa semilla, en lugar de requerir la restauración de cada clave privada. +> :libro: ***¿Qué es una billetera HD?*** La mayoría de las billeteras modernas se basan en [BIP32: billeteras deterministas jerárquicas](https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki). Se trata de un diseño jerárquico en el que se puede utilizar una única semilla para generar una secuencia completa de claves. La billetera completa se puede restaurar a partir de esa semilla, en lugar de requerir la restauración de cada clave privada. > :book: ***¿Qué es una ruta de derivación?*** Cuando tiene claves jerárquicas, necesita poder definir claves individuales como descendientes de una semilla. Por ejemplo, `[0]` es la clave 0, `[0/1]` es el primer hijo de la clave 0, `[1/0/1]` es el primer nieto del hijo cero de la primera clave. Algunas claves también contienen un `'` después del número, para mostrar que están endurecidas, lo que las protege de un ataque específico que se puede usar para derivar un `xprv` de un`xpub`. No necesita preocuparse por los detalles, aparte del hecho de que esos `'` s le causarán problemas de formato cuando trabaje desde la línea de comandos. @@ -71,7 +71,7 @@ function([derivation-path]key)#checksum Esto es lo que todo eso significa: * **Función.** La función que se utiliza para crear una dirección a partir de esa tecla. En estos casos, es `pkh`, que es la dirección heredada P2PKH estándar que conoció en [§3.3: Configuración de su billetera](03_3_Configurando_Su_Billetera.md). De manera similar, una dirección P2WSH SegWit usaría `wsh` y una dirección P2WPKH usaría` wpkh`. * **Ruta de derivación.** Esto describe qué parte de una billetera HD se está exportando. En este caso, es una semilla con la huella digital `d6043800` y luego el hijo 18 del hijo 0 del hijo 0 (` 0'/ 0'/18'`) de esa semilla. También puede haber una derivación adicional después de la clave: `función ([ruta de derivación] clave / más-derivación) # suma de comprobación` - * Vale la pena señalar aquí que si alguna vez obtiene una ruta de derivación sin una huella digital, puede inventarla. Es solo que si hay uno existente, debe coincidir, porque si alguna vez regresa al dispositivo que creó la huella digital, deberá tener el mismo. + * Vale la pena señalar aquí que si alguna vez obtiene una ruta de derivación sin una huella digital, puede inventarla. Es solo que si hay una existente, debe coincidir, porque si alguna vez regresa al dispositivo que creó la huella digital, deberá tener la misma. * **Clave**. La clave o claves que se están transfiriendo. Esto podría ser algo tradicional como un `xpub` o` xprv`, podría ser simplemente una clave pública para una dirección, como en este caso, podría ser un conjunto de direcciones para una firma múltiple, o podría ser otra cosa. Estos son los datos centrales: la función explica qué hacer con ellos. * **Suma de comprobación**. Los descriptores están destinados a ser transferibles por humanos. Esta suma de comprobación asegura que lo haga bien. @@ -90,7 +90,7 @@ $ bitcoin-cli getdescriptorinfo "pkh([d6043800/0'/0'/18']03efdee34c0009fd175f3b2 "hasprivatekeys": false } ``` -Tenga en cuenta que devuelve una suma de comprobación. Si alguna vez le dan un descriptor sin una suma de verificación, puede aprenderlo con este comando: +Tenga en cuenta que devuelve una suma de comprobación. Si alguna vez le dan un descriptor sin una suma de verificación, puede conocerlo con este comando: ``` $ bitcoin-cli getdescriptorinfo "pkh([d6043800/0'/0'/18']03efdee34c0009fd175f3b20b5e5a5517fd5d16746f2e635b44617adafeaebc388)" { @@ -152,6 +152,6 @@ Los descriptores le permiten pasar claves públicas y claves privadas entre bill Haremos un uso real de los descriptores en [§7.3](07_3_Integrando_con_Hardware_Wallets.md), cuando estemos importando direcciones desde una billetera de hardware. -## ¿Que sigue? +## ¿Qué sigue? Avance a través de "bitcoin-cli" con el [Capítulo cuatro: Enviando Transacciones Bitcoin](04_0_Enviando_Transacciones_Bitcoin.md). diff --git a/es/04_1_Enviando_Monedas_de_la_Forma_Facil.md b/es/04_1_Enviando_Monedas_de_la_Forma_Facil.md index b16d2124b..72b6b2ca7 100644 --- a/es/04_1_Enviando_Monedas_de_la_Forma_Facil.md +++ b/es/04_1_Enviando_Monedas_de_la_Forma_Facil.md @@ -10,7 +10,7 @@ Antes de enviar dinero en la red Bitcoin, debe pensar en las comisiones por tran Cuando se utilizan los métodos simples y automatizados para crear transacciones, como se indica aquí y en [§4.5: Enviando Monedas con Transacciones Automatizadas en Crudo](04_5_Enviando_Monedas_con_Transacciones_Crudas_Automatizadas.md), Bitcoin calculará las tasas de transacción por usted. Esto se hace utilizando tasas flotantes, donde `bitcoind` observa el tiempo que tardan las transacciones en confirmarse y calcula automáticamente lo que se debe gastar. -Puede controlar esto colocando valores racionales en su fichero `~/.bitcoin/bitcoin.conf`. Los siguientes valores de bajos costes se asegurarían que haya una tasa mínima de 10,000 satoshis de comisión por kByte de data en su trasacción y solicitarían que las tasas flotantes se calcularan con una cantidad atractiva para que la transacción sea procesada en los siguientes seis bloques. +Puede controlar esto colocando valores racionales en su fichero `~/.bitcoin/bitcoin.conf`. Los siguientes valores de bajos costes se asegurarían que haya una tasa mínima de 10,000 satoshis de comisión por kByte de data en su transacción y solicitarían que las tasas flotantes se calcularan con una cantidad atractiva para que la transacción sea procesada en los siguientes seis bloques. ``` mintxfee=0.0001 txconfirmtarget=6 diff --git a/es/04_2_Creando_una_Transaccion_Cruda.md b/es/04_2_Creando_una_Transaccion_Cruda.md index 17348bdaf..541756cee 100644 --- a/es/04_2_Creando_una_Transaccion_Cruda.md +++ b/es/04_2_Creando_una_Transaccion_Cruda.md @@ -118,17 +118,22 @@ Ahora está listo para crear la transacción en crudo. Esto utiliza el comando ` Este es el formato estándar: ``` -$ bitcoin-cli createrawtransaction -'''[ - { - "txid": "'$your_txid'", - "vout": '$your_vout' - } -]''' -'''{ - "'$your_recipient'": bitcoin_amount +$ bitcoin-cli createrawtransaction \ +'''[ \ + { \ + "txid": "'$your_txid'", \ + "vout": '$your_vout' \ + } \ +]''' \ +'''{ \ + "'$your_recipient'": bitcoin_amount \ }''' ``` + + standup@mybtctest:~$ utxo_txid="379341f85991ba1453aa5ea959128efb64b89bc0b1320e064dd50e2c26b9b1f7" +standup@mybtctest:~$ utxo_vout="0" +standup@mybtctest:~$ recipient="n2eMqTT929pb1RDNuqEnxdaLau1rxy3efi" + Sí, hay todo tipo de comillas locas ahí, pero confíe en que harán lo correcto. Use `'''` para marcar el inicio y el final del array JSON y del objeto JSON. Protege las palabras normales como `"this"`, pero no necesita proteger los números normales: `0`. Si son variables, inserta comillas simples, como `"'$this_word'"` y `'$this_num'`. (Ya se acostumbrá). Aquí hay un comando que crea una transacción en crudo para enviar su $utxo a su $recipient diff --git a/es/04_4_Interludio_Usando_Curl.md b/es/04_4_Interludio_Usando_Curl.md index e7321197c..0f58bf792 100644 --- a/es/04_4_Interludio_Usando_Curl.md +++ b/es/04_4_Interludio_Usando_Curl.md @@ -221,7 +221,7 @@ Esta es casi la misma salida que recibe cuando escribe `bitcoin-cli listunspent` Después de saber dónde están sus fondos, el siguiente paso en la elaboración de una transacción es conseguir una dirección de cambio. A estas alturas, probablemente ya se haya hecho a la idea, y sabe que para los comandos RPC simples, todo lo que necesita hacer es ajustar el `method` es el comando `curl`: ``` -$ curl --user StandUp:8eaf562eaf45c33c3328bc66008f2dd1 --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getrawchangeaddress", "params": ["", "legacy"] }' -H 'content-type: text/plain;' http://127.0.0.1:18332/ | jq -r '.' +$ curl --user StandUp:8eaf562eaf45c33c3328bc66008f2dd1 --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getrawchangeaddress", "params": ["legacy"] }' -H 'content-type: text/plain;' http://127.0.0.1:18332/ | jq -r '.' { "result": "mrSqN37TPs89GcidSZTvXmMzjxoJZ6RKoz", "error": null, @@ -231,7 +231,7 @@ $ curl --user StandUp:8eaf562eaf45c33c3328bc66008f2dd1 --data-binary '{"jsonrpc" En este punto, podemos incluso volver a nuestra práctica estándar de guardar los resultados en variables con la ayuda adicional de `jq`: ``` -$ changeaddress=$(curl --user StandUp:8eaf562eaf45c33c3328bc66008f2dd1 --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getrawchangeaddress", "params": ["", "legacy"] }' -H 'content-type: text/plain;' http://127.0.0.1:18332/ | jq -r '.result') +$ changeaddress=$(curl --user StandUp:8eaf562eaf45c33c3328bc66008f2dd1 --data-binary '{"jsonrpc": "1.0", "id":"curltest", "method": "getrawchangeaddress", "params": ["legacy"] }' -H 'content-type: text/plain;' http://127.0.0.1:18332/ | jq -r '.result') $ echo $changeaddress mqdfnjgWr2r3sCCeuTDfe8fJ1CnycF2e6R ``` diff --git a/es/04_5_Enviando_Monedas_con_Transacciones_Crudas_Automatizadas.md b/es/04_5_Enviando_Monedas_con_Transacciones_Crudas_Automatizadas.md index 72f81f78e..06466c050 100644 --- a/es/04_5_Enviando_Monedas_con_Transacciones_Crudas_Automatizadas.md +++ b/es/04_5_Enviando_Monedas_con_Transacciones_Crudas_Automatizadas.md @@ -6,7 +6,7 @@ Este capítulo expone tres formas de enviar fondos a través de la interfaz cli La metodología para automatizar las transacciones en crudo es sencilla: usted crea una transacción en crudo, pero utiliza el comando `fundrawtransaction` para pedir a bitcoind que realice los cálculos por usted. -Para utilizar este comando, tendrá que asegurarse de que tu archivo ~/.bitcoin/bitcoin.conf contiene variables racionales para calcular las tasas de las transacciones. Por favor, consulta [§4.1: Enviando Monedas de la Forma Fácil](04_1_Enviando_Monedas_de_la_Forma_Facil.md) para más información al respecto. +Para utilizar este comando, tendrá que asegurarse de que su archivo ~/.bitcoin/bitcoin.conf contiene variables racionales para calcular las tasas de las transacciones. Por favor, consulte [§4.1: Enviando Monedas de la Forma Fácil](04_1_Enviando_Monedas_de_la_Forma_Facil.md) para más información al respecto. Para números muy conservadores, sugerimos añadir lo siguiente al `bitcoin.conf`: ``` diff --git a/es/05_0_Controlando_Transacciones_Bitcoin.md b/es/05_0_Controlando_Transacciones_Bitcoin.md index 7d651aa1f..1b53798b2 100644 --- a/es/05_0_Controlando_Transacciones_Bitcoin.md +++ b/es/05_0_Controlando_Transacciones_Bitcoin.md @@ -1,20 +1,20 @@ # Capitulo Cinco: Controlar Las Transacciones de Bitcoin -Enviar una transacción no siempre es el final de la historia. Al usar los protocolos RBF (reemplazo por tarifa) y CPFP (el niño paga por el padre), un desarrollador puede continuar controlando la transacción después de que se haya enviado, para mejorar la eficiencia o recuperar transacciones que se atascan. Estos métodos comenzarán a destacar el verdadero poder de Bitcoin. +Enviar una transacción no siempre es el final de la historia. Al usar los protocolos RBF (reemplazo por tarifa) y CPFP (el hijo paga por el padre), un desarrollador puede continuar controlando la transacción después de que se haya enviado, para mejorar la eficiencia o recuperar transacciones que se atascan. Estos métodos comenzarán a destacar el verdadero poder de Bitcoin. ## Objetivos de Esta Sección: Después de trabajar en este capítulo, un desarrollador podrá: - * Decida si RBF o CPFP pueden ayudar en una transacción + * Decidir si RBF o CPFP pueden ayudar en una transacción * Crear transacción de reemplazo usando RBF * Crear nuevas transacciones con CPFP Los objetivos de apoyo incluyen la capacidad de: * Entender la mempool - * Comprenda la diferencia entre RBF y CPFP - * Planifique el poder de RBF + * Comprender la diferencia entre RBF y CPFP + * Planificar el poder de RBF ## Tabla de Contenido diff --git a/es/05_1_Vigilando_por_Transacciones_Estancadas.md b/es/05_1_Vigilando_por_Transacciones_Estancadas.md index e30987140..e856461d6 100644 --- a/es/05_1_Vigilando_por_Transacciones_Estancadas.md +++ b/es/05_1_Vigilando_por_Transacciones_Estancadas.md @@ -34,9 +34,9 @@ $ bitcoin-cli -named gettransaction txid=fa2ddf84a4a632586d435e10880a2921db6310d ``` Una transacción puede considerarse bloqueada si permanece en este estado durante un período de temipo prolongado. No hace muchos años, podía estar seguro do que todas las transacciones saldrían _eventualmente_. Pero, ese ya no es el caso debido al mayor uso de Bitcoin. Ahora, si una transacción se atasca demasiado tiempo, saldrá del mempool y luego se perderá de la red Bitcoin. -> :book: ***Que es mempool?*** Mempool (o Pool de Memoria) es un grupo de todas las transacciones no confirmadas en un nodo bitcoin. Estas son las transacciones que un nodo ha recibido de la red p2p que aún no están incluidas en un bloque. Cada nodo de bitcoin puede tener un conjunto de transacctiones ligeramente diferente en su mempool: diferentes transacciones pueden haberse propagado a un nodo específico. Esto depende de cuándo se inició el nodo por última vez y también de sus límites sobre cuánto está dispuesto a almacenar. Cuando un minero hace un bloqueo, usa transacciones de su mempool. Luego cuando se verifica un bloque, todos los mineros eliminan las transacciones que contiene de sus grupos. A partir de Bitcoin 0.12, las transacciones no confirmadas también pueden vencer de la mempool si tienen la antigüedad suficiente, por lo general, 72 horas, y a partir de la versión 0.14.0, el tiempo de desalojo se incrementó a 2 semanas. Los grupos de minería pueden tener sus propios mecanismos de gestión de mempool. +> :book: ***Que es mempool?*** Mempool (o Pool de Memoria) es un grupo de todas las transacciones no confirmadas en un nodo bitcoin. Estas son las transacciones que un nodo ha recibido de la red p2p que aún no están incluidas en un bloque. Cada nodo de bitcoin puede tener un conjunto de transacciones ligeramente diferente en su mempool: diferentes transacciones pueden haberse propagado a un nodo específico. Esto depende de cuándo se inició el nodo por última vez y también de sus límites sobre cuánto está dispuesto a almacenar. Cuando un minero hace un bloque, usa transacciones de su mempool. Luego cuando se verifica un bloque, todos los mineros eliminan las transacciones que contiene de sus grupos. A partir de Bitcoin 0.12, las transacciones no confirmadas también pueden vencer de la mempool si tienen la antigüedad suficiente, por lo general, 72 horas, y a partir de la versión 0.14.0, el tiempo de desalojo se incrementó a 2 semanas. Los grupos de minería pueden tener sus propios mecanismos de gestión de mempool. -Es posible que esta lista de todos las [transacciones no confirmadas](https://blockchain.info/unconfirmed-transactions) no coincida con el mempool de ninguna máquina individual, pero debería (en su mayoría) ser un superconjunto de ellas. +Es posible que esta lista de todas las [transacciones no confirmadas](https://blockchain.info/unconfirmed-transactions) no coincida con el mempool de ninguna máquina individual, pero debería (en su mayoría) ser un superconjunto de ellas. ## Decidir Que Hacer @@ -44,16 +44,16 @@ Si su transacción se atasca más de lo que deseas, normalmente puede hacer una **1. Espere Hasta Que Se Aclare.** Se envió su transacción con una tarifa baja o media, eventualmente debería pasar. Como se muestra en [Mempool Space](https://mempool.space), aquellos con tarifas más bajas _se retrasarán_. (Eche un vistazo a la transacción más a la izquierda y vea cuánto tiempo ha estado esperando y cuánto pagó por su tarifa) -**2. Espere Hasta Que Expire.** Se envió accidentalmente sin tarifa de transacción, o si se cumplen otras condiciones, es posible que su transacción nunca se realice. Sin embargo, sus monedas no se pierden. Siempre que no tenga una billetera que reenvíe intencionalmente las transacciones no confirmadas, debería borrarse del mempool en aproximadamente tres días, y luego puede volver a intentarlo. +**2. Espere Hasta Que Expire.** Se envió accidentalmente sin tarifa de transacción, o si se cumplen otras condiciones, es posible que su transacción nunca se realice. Sin embargo, sus monedas no se pierden. Siempre que no tenga una billetera que reenvíe intencionalmente las transacciones no confirmadas, debería borrarse de la mempool en aproximadamente tres días, y luego puede volver a intentarlo. -**3. Utilice RBF Como Remitente.** Si usted es el remitente de la transacción y se inscribió en RBF (Replace by fee / Reemplazar Por Tarifa), puede volver a intentarlo con una tarifa más alta. Consulte [§5.2: Reenviando una Transacción con RBF](05_2_Reenviando_a_Transaccion_con_RBF.md). +**3. Utilice RBF Como Remitente.** Si usted es el remitente de la transacción y se inscribió en RBF (Replace By Fee / Reemplazar Por Tarifa), puede volver a intentarlo con una tarifa más alta. Consulte [§5.2: Reenviando una Transacción con RBF](05_2_Reenviando_a_Transaccion_con_RBF.md). -**4. Us CPFP Como La Receptora.** Alternativeamente, si usted es el receptor de la transacción, puede usar CPFP (Child-pays-for-parent / nino-paga-por-el-padre) para usar la transacción no confirmada como entrada para una nueva transacción. Consulte [§5.3: Financiando una Transacción con CPFP](05_3_Financiando_una_Transaccion_con_CPFP.md). +**4. Use CPFP Como La Receptora.** Alternativeamente, si usted es el receptor de la transacción, puede usar CPFP (Child-Pays-For-Parent / Hijo-Paga-Por-el-Padre) para usar la transacción no confirmada como entrada para una nueva transacción. Consulte [§5.3: Financiando una Transacción con CPFP](05_3_Financiando_una_Transaccion_con_CPFP.md). ## Resumen: Observación de Transacciones Atascadas Esta es una introducción al poder de las transacciónes de Bitcoin. Si lo sabe que una transacción está atascada, puede decidir liberarla con funciones como RBF o CPFP. -## Que Sigue? +## ¿Qué Sigue? Continúe "Controlando las Transacciones de Bitcoin" con [§5.2: Reenviando una Transacción con RBF](05_2_Reenviando_a_Transaccion_con_RBF.md). diff --git a/es/05_2_Reenviando_a_Transaccion_con_RBF.md b/es/05_2_Reenviando_a_Transaccion_con_RBF.md index 573e89e1e..8e9918ad4 100644 --- a/es/05_2_Reenviando_a_Transaccion_con_RBF.md +++ b/es/05_2_Reenviando_a_Transaccion_con_RBF.md @@ -210,6 +210,6 @@ Si una transacción está atascada y no desea esperar a que caduque por completo > Por ejemplo, puede enviar una transacción y luego, antes de que se confirme, combinarla con una segunda transacción. Esto le permite comprimir múltiples transacciones en una sola, disminuyendo las tarifas generales. También podría ofrecer beneficios a la privacidad. También hay otras razones para usar RBF, para contratos inteligentes o transacciones de corte, como se describe en el [Opt-in RBF FAQ](https://bitcoincore.org/en/faq/optin_rbf/). -## Que Sigue? +## ¿Qué Sigue? -Continúe "Controlando las Transacciones de Bitcoin" con [§5.3: Financiando una Transacción con CPFP](05_3_Financiando_una_Transaccion_con_CPFP.md). +Continúe "Controlando las Transacciones de Bitcoin" con [§5.3: Financiando una Transacción con CPFP](05_3_Financiando_una_Transaccion_con_CPFP.md). diff --git a/es/05_3_Financiando_una_Transaccion_con_CPFP.md b/es/05_3_Financiando_una_Transaccion_con_CPFP.md index bdbcb69f2..b1f8f96ab 100644 --- a/es/05_3_Financiando_una_Transaccion_con_CPFP.md +++ b/es/05_3_Financiando_una_Transaccion_con_CPFP.md @@ -1,6 +1,6 @@ # 5.3: Financiación de una Transación con CPFP -Si su transacción de Bitocin está atascada y usted es el _receptor_, puede borrarla usando CPFP (child-pays-for-parent o el niño paga por el padre). Esta es una alternativa a la capacidad del _remitente_ para hacerlo con RBF. +Si su transacción de Bitcoin está atascada y usted es el _receptor_, puede borrarla usando CPFP (child-pays-for-parent o el hijo paga por el padre). Esta es una alternativa a la capacidad del _remitente_ para hacerlo con RBF. > :warning: **ADVERTENCIA DE VERSIÓN:** Esta es una innovación de Bitcoin Core v 0.13.0, lo que nuevamente significa que la mayoría de la gente ya debería estar usándolo. @@ -10,15 +10,16 @@ RBF se trataba del remitente. Se equivocó y necesitaba aumentar la tarifa, o qu Básicamente, la idea de CPFP es que un destinatario tiene una transacción que no ha sido confirmada en un bloque que quiere gastar. Entonces, incluye esa transacción no confirmada en una nueva transacción y paga una tarifa lo suficientemente alta como para alentar a un minero a incluir tanto la transacción original (principal) como la nueva transacción (secundaria) en un bloque. Como resultado, las transacciones principales y secundarias se borran simultáneamnete. -Cabe señalar que CPFP no es una función de protocolo nueva como RBF. Es solo un nuevo esquema de incentivos que los mineros pueden usar para la selección de transacciones. Esto también significa que no es tan confiable como un cambio de protocolo como RBF: puede haber razones por las que la secundaria no sea seleccionado para ser colocado en un bloque, y eso evitará que el principal sea colocado en un bloque. +Cabe señalar que CPFP no es una función de protocolo nueva como RBF. Es solo un nuevo esquema de incentivos que los mineros pueden usar para la selección de transacciones. Esto también significa que no es tan confiable como un cambio de protocolo como RBF: puede haber razones por las que la secundaria no sea seleccionada para ser colocada en un bloque, y eso evitará que la principal sea colocada en un bloque. ## Gastar UTXOs No Confirmadas Financiar una transacción con CPFP es un proceso muy simple que utiliza los métodos con los que ya está familiarizado: 1. Busque el `txid` y `vout` de la transacción no confirmada. Esta puede ser la parte más complicada, ya que `bitcoin-cli` generalmente intenta protegerlo de transaciones no confirmadas. Es posible que el remitente pueda enviarle esta información; incluso con solo el `txid`, debería poder averigular el `vout` en un explorador de blockchain. - Tiene otra opción: use `bitcoin-cli getrawmempool`, que se puede usar para enumerar el contenido de su mempool completo, donde se encontrarán las transacciones no confirmadas. Es posible que tenga que buscar en varios se el mempool está particularmente ocupado. A continuación, puede obtener más información sobre una transacción especifica con `bitcoin-cli getrawtransaction` con el indicador detallado en `true`: - ``` + Tiene otra opción: use `bitcoin-cli getrawmempool`, que se puede usar para enumerar el contenido de su mempool completo, donde se encontrarán las transacciones no confirmadas. Es posible que tenga que buscar en varios si el mempool está particularmente ocupado. A continuación, puede obtener más información sobre una transacción especifica con `bitcoin-cli getrawtransaction` con el indicador detallado en `true`: + +``` $ bitcoin-cli getrawmempool [ "95d51e813daeb9a861b2dcdddf1da8c198d06452bbbecfd827447881ff79e061" @@ -121,6 +122,6 @@ Puede aprovechar los incentivos de CPFP para liberar fondos que le han sido envi > :fire: ***¿Cuál es el Poder de CPFP?*** Principalmente, CPFP es útil para que los fondos se despeguen cuando usted es el destinatario y el remitente no está siendo útil por cualquier motivo. No tiene las posibilidades más poderosas de RBF, pero es una forma alternativa de ejercer control sobre una transacción después de que se haya colocado en el mempool, pero antes de que se confirme en un bloque. -## Que Sigue? +## ¿Qué Sigue? Avance a través de "bitcoin-cli" con [Capitulo seis: Expandiendo las Transacciones Bitcoin con Multifirmas](06_0_Expandiendo_las_Transacciones_Bitcoin_con_Multifirmas.md). diff --git a/es/06_1_Enviando_una_Transaccion_a_una_Direccion_Multifirma.md b/es/06_1_Enviando_una_Transaccion_a_una_Direccion_Multifirma.md index 6b51add19..8c1cadc95 100644 --- a/es/06_1_Enviando_una_Transaccion_a_una_Direccion_Multifirma.md +++ b/es/06_1_Enviando_una_Transaccion_a_una_Direccion_Multifirma.md @@ -12,7 +12,7 @@ Técnicamente, un rompecabezas criptográfico multifirma es creado por Bitcoin u > :book: ***¿Qué es una transacción multifirma?*** Una transacción mutifirma es una transacción de Bitcoin que ha sido enviada a una dirección multifirma, requiriendo así la firma de ciertas personas del grupo multifirma para reutilizar los fondos. -Multifirmas simples requieren que todos en el grupo firmen el UTXO cuando sea gastado. Sin embargo, es posible una mayor complejidad. Las multifirmas son descriptas generalmente como "m de n". Esto significa que la transacción está bloqueada con un grupo de "n" claves, pero sólo "m" de ellas son requeridas para desbloquear la transacción. +Multifirmas simples requieren que todos en el grupo firmen el UTXO cuando sea gastado. Sin embargo, es posible una mayor complejidad. Las multifirmas son descritas generalmente como "m de n". Esto significa que la transacción está bloqueada con un grupo de "n" claves, pero sólo "m" de ellas son requeridas para desbloquear la transacción. > :book: ***¿Qué es una multifirma m-de-n?*** En una multifirma, "m" firmas de un grupo de "n" son requeridas para formar la firma, donde "m ≤ n". diff --git a/es/08_1_Enviando_una_Transaccion_con_Bloqueo_de_Tiempo.md b/es/08_1_Enviando_una_Transaccion_con_Bloqueo_de_Tiempo.md index 9a9455bd3..4a74524ea 100644 --- a/es/08_1_Enviando_una_Transaccion_con_Bloqueo_de_Tiempo.md +++ b/es/08_1_Enviando_una_Transaccion_con_Bloqueo_de_Tiempo.md @@ -29,7 +29,7 @@ Con mayor frecuencia, establecerá el tiempo de bloqueo en una marca de tiempo d >tiempo de bloqueo que está muy alejado en el futuro, es lo más seguro que puede hacer. Pero, más allá de eso, es más intuitivo, ya que crea una >correlación directa entre alguna fecha del calendario y el momento en que se puede extraer la transacción. ->:warning: **ADVERTENCIA:** El tiempo de bloqueo con marcas de tiempo de UNIX tiene poco margen de maniobra: la liberación de bloques no es regular y los tiempos de bloqueo pueden adelantarse dos horas al tiempo real, por lo que un tiempo de bloqueo en realidad significa "dentro de unas pocos horas de este tiempo, más o menos". +>:warning: **ADVERTENCIA:** El tiempo de bloqueo con marcas de tiempo de UNIX tiene poco margen de maniobra: la liberación de bloques no es regular y los tiempos de bloqueo pueden adelantarse dos horas al tiempo real, por lo que un tiempo de bloqueo en realidad significa "dentro de unas pocas horas de este tiempo, más o menos". ### Calcule su tiempo de bloqueo por altura de bloque @@ -134,6 +134,6 @@ Locktime ofrece una forma de crear una transacción que _debería_ no ser retran >:fire: _¿Cuál es el poder del tiempo de bloqueo?_ El poder del tiempo de bloqueo puede no ser inmediatamente obvio debido a la capacidad de cancelarlo tan fácilmente. Sin embargo, es otra de las bases de los contratos inteligentes: tienen mucha utilidad en una variedad de aplicaciones de custodia o contractuales. Por ejemplo, considere una situación en la que un tercero tiene sus bitcoins. Para garantizar la devolución de sus bitcoins si el custodio alguna vez desapareciera, podrían producir una transacción de bloqueo de tiempo para devolverle las monedas y luego actualizarlas de vez en cuando con una nueva, en el futuro. Si alguna vez no se actualizaran, las monedas le regresarían cuando expirara el bloqueo de tiempo actual. El tiempo de bloqueo podría aplicarse de manera similar a una red de pago, donde la red contiene monedas mientras los participantes de la red las intercambian. Finalmente, un testamento ofrece un ejemplo de un contrato más complejo, en el que los pagos se envían a varias personas. Estos pagos se basarían en transacciones de tiempo de bloqueo y se actualizarían continuamente siempre que el propietario continúe mostrando signos de vida. (El factor unificador de todas estas aplicaciones es por supuesto, la _confianza_. Las transacciones simples de tiempo de bloqueo solo funcionan si se puede confiar en que el poseedor de las monedas las enviará en las condiciones adecuadas). -## ¿Que sigue? +## ¿Qué sigue? Continúe "Expandiendo transacciones de Bitcoin" con [§8.2: Enviando una Transacción con Datos](08_2_Enviando_una_Transaccion_con_Datos.md). diff --git a/es/08_2_Enviando_una_Transaccion_con_Datos.md b/es/08_2_Enviando_una_Transaccion_con_Datos.md index d61ac0d4a..c78d3fe8d 100644 --- a/es/08_2_Enviando_una_Transaccion_con_Datos.md +++ b/es/08_2_Enviando_una_Transaccion_con_Datos.md @@ -120,6 +120,6 @@ Puede usar un opcode OP_RETURN para almacenar hasta 80 bytes de datos en la cade Tenga en cuenta que existe cierta controversia sobre el uso de la cadena de bloques de Bitcoin de esta manera. -## ¿Que sigue? +## ¿Qué sigue? Pase a "Codificar con Bitcoin" en [Capítulo nueve: Introduciendo Bitcoin Scripts](09_0_Introduciendo_Bitcoin_Scripts.md). diff --git a/es/09_2_Ejecutando_un_Script_Bitcoin.md b/es/09_2_Ejecutando_un_Script_Bitcoin.md index d82c2606c..316f448c6 100644 --- a/es/09_2_Ejecutando_un_Script_Bitcoin.md +++ b/es/09_2_Ejecutando_un_Script_Bitcoin.md @@ -18,7 +18,7 @@ Por ejemplo, si estuviera sumando "1" y "2", su script de Bitcoin para eso serí En realidad, no es del todo correcto decir que un operador se aplica a las entradas anteriores. Realmente, un operador aplica a las entradas superiores en la pila de Bitcoin. ->:book: ***¿Qué es una pila?*** Una pila es una estructura de datos LIFO (último en entrar, primero en salir). Tiene dos funciones de acceso: Empujar y quitar. Empujar (push) coloca un nuevo objeto en la parte superior de la pila, empujando hacia abajo todo lo que está debajo. Y la fuunció de quitar (Pop) elimina el objeto superior de la pila. +>:book: ***¿Qué es una pila?*** Una pila es una estructura de datos LIFO (último en entrar, primero en salir). Tiene dos funciones de acceso: Empujar y quitar. Empujar (push) coloca un nuevo objeto en la parte superior de la pila, empujando hacia abajo todo lo que está debajo. Y la función de quitar (Pop) elimina el objeto superior de la pila. Siempre que Bitcoin Script encuentra una constante, la empuja a la pila. Entonces, el ejemplo anterior de `1 2 OP_ADD` en realidad se vería así cuando se procesó: diff --git a/es/09_3_Probando_un_Script_Bitcoin.md b/es/09_3_Probando_un_Script_Bitcoin.md index f562a899c..9309f1335 100644 --- a/es/09_3_Probando_un_Script_Bitcoin.md +++ b/es/09_3_Probando_un_Script_Bitcoin.md @@ -205,6 +205,6 @@ _Independientemente_ de los otros métodos de prueba que haya utilizado, probar Debería instalar `btcdeb` como una herramienta de línea de comandos para probar sus scripts de Bitcoin. En el momento de escribir este artículo, produce resultados precisos que pueden recorrer todo el proceso de creación de scripts. También puede buscar en algunos sitios en línea para obtener una representación más visual. Cuando haya terminado, deberá ir a testnet para asegurarse de que todo funciona correctamente, antes de implementarlo de manera más general. -## ¿Que sigue? +## ¿Qué sigue? Continue con "Introduciendo Bitcoin Scripts" con nuestro primer ejemplo de la vida real: [§9.4: Codificando una P2PKH](09_4_Codificando_una_P2PKH.md). diff --git a/es/09_4_Codificando_una_P2PKH.md b/es/09_4_Codificando_una_P2PKH.md index 1face675c..b3628b746 100644 --- a/es/09_4_Codificando_una_P2PKH.md +++ b/es/09_4_Codificando_una_P2PKH.md @@ -390,6 +390,6 @@ Sin embargo, descubrir esa firma requiere comprender realmente los detalles de c Enviar a una dirección P2PKH era relativamente fácil cuando solo usaba `bitcoin-cli`. Al examinar el script de Bitcoin subyacente, se ponen al descubierto las funciones criptográficas que estaban implícitas en la financiación de esa transacción: cómo se desbloqueó el UTXO con una firma y una clave pública. -## ¿Que sigue? +## ¿Qué sigue? Continúe "Introduciendo los scripts de Bitcoin" con [§9.5: Codificando una P2WPKH](09_5_Codificando_una_P2WPKH.md). diff --git a/es/09_5_Codificando_una_P2WPKH.md b/es/09_5_Codificando_una_P2WPKH.md index e14ff5d5d..face959da 100644 --- a/es/09_5_Codificando_una_P2WPKH.md +++ b/es/09_5_Codificando_una_P2WPKH.md @@ -118,6 +118,6 @@ Sin embargo, SegWit también fue un uso inteligente de los scripts de Bitcoin. S Cuando está programando desde la línea de comandos, fundamentalmente no tiene que preocuparse por esto, aparte de saber que no encontrará scripts tradicionales en transacciones SegWit sin procesar (que, nuevamente, era el punto). -## ¿Que sigue? +## ¿Qué sigue? Continúe "Codificando Bitcoin" con el [Capítulo 10: Embebiendo Bitcoin Scripts en Transacciones P2SH](10_0_Embebiendo_Bitcoin_Scripts_en_Transacciones_P2SH.md). diff --git a/es/10_1_Entendiendo_la_Base_de_P2SH.md b/es/10_1_Entendiendo_la_Base_de_P2SH.md index 54607d94e..5f8bc4cd6 100644 --- a/es/10_1_Entendiendo_la_Base_de_P2SH.md +++ b/es/10_1_Entendiendo_la_Base_de_P2SH.md @@ -7,11 +7,11 @@ Sabe que los scripts de Bitcoin se pueden usar para controlar el canje de UTXOs. Aquí está la trampa para usar los scripts de Bitcoin: por razones de seguridad, la mayoría de los nodos de Bitcoin solo aceptarán seis tipos de transacciones de Bitcoin "estándar". * __Pagar a Clave Pública (Pay to Public Key, P2PK)__ — Una transacción antigua y obsoleta (` OP_CHECKSIG`) que ha sido reemplazada por la mejor seguridad de P2PKH. -* __Pagar al Testigo del Hash de la Clave Pública (Pay to Public Key Hash, P2PKH)__ — Una transacción (`OP_DUP OP_HASH160 OP_EQUALVERIFY OP_CHECKSIG`) que paga el hash de una clave pública. -* __Pagar Para Ser Testigo de Hash de Clave Pública (Pay to Witness Public Key Hash, P2WPKH)__ — El tipo más nuevo de transacción de clave pública. Es solo (`OP_0 OP_EQUALVERIFY OP_CHECKSIG`) que paga el hash de una clave pública. +* __Pagar Para Ser Testigo del Hash de Clave Pública (Pay to Witness Public Key Hash, P2WPKH)__ — El tipo más nuevo de transacción de clave pública. Es solo (`OP_0 OP_EQUAL`. Eso es un P2SH normal según [§10.2](10_2_Construyendo_la_Estructura_de_P2SH.md), lo que significa que es solo cuando se ejecuta el script de canje que ocurre la magia. Al igual que con un P2WPKH, un nodo antiguo verá `OP_0 OP_PUSHDATA (20 bytes) 3ab2a09a1a5f2feb6c799b5ab345069a96e1a0a` en el script de canje y lo verificará automáticamente, mientras que un nuevo nodo lo verá, sabrá que es un P2WPKH, y así irá a los `witnesses`. Consulte [§9.5: Codificando una P2WPKH](09_5_Codificando_una_P2WPKH.md). > :book: ***¿Cuáles son las desventajas de las transacciones segwit anidadas?*** Son más grandes que las transacciones nativas de Segwit, por lo que obtiene algunas de las ventajas de Segwit, pero no todas. @@ -116,8 +114,9 @@ Los detalles muestran que un UTXO enviado a esta dirección está bloqueado con ``` OP_0 OP_PUSHDATA (32 bytes) 1863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262 ``` -Esto funciona como una dirección P2WPKH, la única diferencia es que un lugar de un hash de clave pública de 20 bytes, el UTXO incluye un hash de script de 32 bytes. Al igual que con un P2WPKH, los nodos antiguos solo verifican esto, mientras que los nuevos nodos reconocen que se trata de un P2WSH y, por lo tanto, verifican internamente el script como se describe en las secciones anteriores, pero utilizando los datos del `testigo`, que ahora incluye el script de canje. -También hay una variante más, un script P2WSH incrustado en un script P2SH, que funciona de manera muy similar al P2SH-Segwit descrito anterioremente, pero para scripts P2WSH anidados. (Whew!) +Esto funciona como una dirección P2WPKH, la única diferencia es que un lugar de un hash de clave pública de 20 bytes, el UTXO incluye un hash de script de 32 bytes. Al igual que con un P2WPKH, los nodos antiguos solo verifican esto, mientras que los nuevos nodos reconocen que se trata de un P2WSH y, por lo tanto, verifican internamente el script como se describe en las secciones anteriores, pero utilizando los datos del `witnesses`, que ahora incluye el script de canje. + +También hay una variante más, un script P2WSH incrustado en un script P2SH, que funciona de manera muy similar al P2SH-Segwit descrito anterioremente, pero para scripts P2WSH anidados. (¡Uf!) ## Resumen: Programando un script Segwit @@ -127,6 +126,6 @@ La dirección P2SH-Segwit es una dirección Segwit anidada que incrusta el simpl La dirección P2WSH es una variante Segwit de P2SH, al igual que P2WPKH es una variante Segwit de P2WSH. Funciona con la misma lógica y se identifica por tener un hash de 32 bytes en lugar de un hash de 20 bytes. El propósito es extender las ventajas de Segwit a otros tipos de scripts. -## Que Sigue? +## ¿Qué Sigue? Continúe "Incrustando Bitcoin Scripts" con [§10.6: Gastando una Transacción P2SH](10_6_Gastando_una_Transaccion_P2SH.md). diff --git a/es/10_6_Gastando_una_Transaccion_P2SH.md b/es/10_6_Gastando_una_Transaccion_P2SH.md index 147a517bc..5282780c4 100644 --- a/es/10_6_Gastando_una_Transaccion_P2SH.md +++ b/es/10_6_Gastando_una_Transaccion_P2SH.md @@ -1,6 +1,6 @@ # 10.6: Gastando una Transacción P2SH -Antes de cerrar esta descripcion general de las transacciones P2SH, veremos cómo gastarlas. Esta sección es principalmente una descripción general, que hace referencia a una sección anterior en la que _ya_ gastamos una transacción P2SH. +Antes de cerrar esta descripción general de las transacciones P2SH, veremos cómo gastarlas. Esta sección es principalmente una descripción general, que hace referencia a una sección anterior en la que _ya_ gastamos una transacción P2SH. ## Utilice el Guión de Canjear @@ -15,7 +15,7 @@ Esto significa que debe recopilar: * El `hex` de la `scriptPubKey` para la transacción que está gastando * El `redeemScript` serializado * Cualquier clave privada, ya que estará firmando a mano - * Todos los `txids`, `vouts`, y `direcciones` regulares que necesitaría + * Todos los `txids`, `vouts`, y `addresses` regulares que necesitaría ## Crear la Transacción @@ -31,12 +31,12 @@ Este es el ejemplo de cómo hacerlo para esa multifirma incrustada en P2SH en § ``` $ bitcoin-cli -named signrawtransactionwithkey hexstring=$rawtxhex prevtxs='''[ { "txid": "'$utxo_txid'", "vout": '$utxo_vout', "scriptPubKey": "'$utxo_spk'", "redeemScript": "'$redeem_script'" } ]''' privkeys='["cNPhhGjatADfhLD5gLfrR2JZKDE99Mn26NCbERsvnr24B3PcSbtR"]' ``` -Con cualquier otro tipo de P2SH, incluirá un `redeemscript` diferente, pero por lo demás, la práctica es exactamente la misma. La única diferencia es que después de dos capítulos de trabajo en Scripts, ahora comprende qué es el `scriptPubKey` y qué es el `redeemScript`, así que con suerte lo que eran elementos misteriosos hace cuatro capítulos ahora es viejo sombrero. +Con cualquier otro tipo de P2SH, incluirá un `redeemscript` diferente, pero por lo demás, la práctica es exactamente la misma. La única diferencia es que después de dos capítulos de trabajo en Scripts, ahora comprende qué es el `scriptPubKey` y qué es el `redeemScript`, así que con suerte lo que eran elementos misteriosos hace cuatro capítulos ahora no son ninguna novedad. ## Resumen: Gastar una Transacción P2SH -Ya gastó un P2SH en el Capítulo 6, cuando reenvió una transacción multifirma de la manera difícil, lo que requirió alinear la información de `scriptPubKey` y `redeemScript`. Ahora sabe que el `scriptPubKey` es un script de bloqueo P2SH estandarizado, mientras que el `redeemScript` coincide con un hash en ese script de bloqueo y que necesita poder ejecutarlo con las variables adecuadas para recibir un resultado `True`. Pero aparte de saber más, no hay nada nuevo en gastar una transacciónn P2SH, porque ya lo hizo! +Ya gastó un P2SH en el Capítulo 6, cuando reenvió una transacción multifirma de la manera difícil, lo que requirió alinear la información de `scriptPubKey` y `redeemScript`. Ahora sabe que el `scriptPubKey` es un script de bloqueo P2SH estandarizado, mientras que el `redeemScript` coincide con un hash en ese script de bloqueo y que necesita poder ejecutarlo con las variables adecuadas para recibir un resultado `True`. Pero aparte de saber más, no hay nada nuevo en gastar una transacciónn P2SH, ¡porque ya lo hizo! -## Que Sigue? +## ¿Qué Sigue? Avanzar a través de "Bitcoin Scripting" con el [Capítulo Once: Potenciando Bloqueos de Tiempo con Bitcoin Scripts](11_0_Potenciando_Bloqueos_de_Tiempo_con_Bitcoin_Scripts.md). diff --git a/es/19_0_Entendiendo_Su_Configuracion_Lightning.md b/es/19_0_Entendiendo_Su_Configuracion_Lightning.md index c9b96af4e..2120a0ae1 100644 --- a/es/19_0_Entendiendo_Su_Configuracion_Lightning.md +++ b/es/19_0_Entendiendo_Su_Configuracion_Lightning.md @@ -4,13 +4,13 @@ El capítulo anterior concluyó nuestro trabajo con Bitcoin propiamente dicho, a través de CLI, scripting y lenguajes de programación. Sin embargo, hay muchas otras utilidades dentro del ecosistema de Bitcoin: este capítulo y el siguiente cubren lo que puede ser el más grande e importante: Lightning Network. -Aquí comenzará a trabajar con la interfaz de línea de comandos `lightning-cli`, entendiendo la configuración de c-lightning y sus características, incluidos algunos ejemplos y la configuración básica. +Aquí comenzará a trabajar con la interfaz de línea de comandos `lightning-cli`, entendiendo la configuración de core lightning y sus características, incluidos algunos ejemplos y la configuración básica. ## Objetivos de este capítulo Después de trabajar en este capítulo, un desarrollador podrá: -* Evaluar que un nodo c-lightning está instalado y actualizado +* Evaluar que un nodo core lightning está instalado y actualizado * Realizar comandos básicos de billetera Lightning * Crea un canal de Lightning @@ -22,8 +22,8 @@ Los objetivos de apoyo incluyen la capacidad de: ## Tabla de contenido -* [Sección uno: Verificación de la configuración de c-lightning](19_1_Verificando_Su_Configuracion_Lightning.md) -* [Sección dos: Conozca su configuración de c-lightning](19_2_Conociendo_Su_Configuracion_Lightning.md) +* [Sección uno: Verificación de la configuración de core lightning](19_1_Verificando_Su_Configuracion_Lightning.md) +* [Sección dos: Conozca su configuración de core lightning](19_2_Conociendo_Su_Configuracion_Lightning.md) * [Interludio: Acceso a un segundo nodo Lightning](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md) * [Sección tres: Creación de un canal Lightning](19_3_Creando_un_Canal_en_Lightning.md) diff --git a/es/19_1_Verificando_Su_Configuracion_Lightning.md b/es/19_1_Verificando_Su_Configuracion_Lightning.md index 32307b372..546d7b446 100644 --- a/es/19_1_Verificando_Su_Configuracion_Lightning.md +++ b/es/19_1_Verificando_Su_Configuracion_Lightning.md @@ -1,14 +1,14 @@ -# 19.1: Creación de una configuración de c-lightning +# 19.1: Creación de una configuración de core lightning > :information_source: **NOTA :** Esta sección se agregó recientemente al curso y es un borrador inicial que aún puede estar pendiente de revisión. Lectura con advertencias. -En esta sección, instalará y verificará c-lightning, su utilidad para acceder a Lightning Network. +En esta sección, instalará y verificará core lightning, su utilidad para acceder a Lightning Network. > :book: ***¿Qué es Lightning Network?*** Lightning Network es una red descentralizada que utiliza la funcionalidad de contrato inteligente de la cadena de bloques de Bitcoin para permitir pagos instantáneos a través de una red de participantes. Lightning está construido como un protocolo de capa 2 que interactúa con Bitcoin para permitir a los usuarios intercambiar sus bitcoins "fuera de la cadena". > :book: ***¿Qué es un protocolo de capa 2?*** La capa 2 se refiere a un protocolo secundario construido sobre el sistema de cadena de bloques de Bitcoin. El objetivo principal de estos protocolos es resolver la velocidad de transacción y las dificultades de escalado que están presentes en Bitcoin: Bitcoin no es capaz de procesar miles de transacciones por segundo (TPS), por lo que se han creado protocolos de capa 2 para resolver el problema de escalabilidad de blockchain. Estas soluciones también se conocen como soluciones de escalado "fuera de la cadena". -## Instalar C-Lightning +## Instalar Core Lightning Si utilizó [Bitcoin Standup Scripts](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts), es posible que ya haya instalado Lightning al comienzo de este curso. Puede probar esto viendo si `lightningd` se está ejecutando: @@ -29,15 +29,15 @@ standup 32072 0.0 0.0 6208 888 pts/0 S+ 15:50 0:00 grep -i lightni Si no es así, deberá instalarlo ahora. Desafortunadamente, si está utilizando Debian, deberá instalarlo a mano, compilando el código fuente, pero aún así debería ser bastante simple si sigue estas instrucciones. Si se encuentra en un sistema Ubuntu estándar, intente [Instalar desde Ubuntu ppa](#variant-install-from-ubuntu-ppa), y siempre puede intentar [Instalar binarios precompilados](#variant-install-binarios precompilados). -> :book: ***¿Qué es c-lightning?*** Hay tres implementaciones diferentes de Lightning en la actualidad: c-lightning, LND y Eclair. Todos deben ser funcionalmente compatibles, basados ​​en las mismas [RFC de BOLT](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), pero sus detalles de implementación pueden ser diferentes. Hemos elegido c-lightning como base de nuestro curso porque también es parte del mismo [Elements Project](https://github.com/ElementsProject) que también contiene Libwally. +> :book: ***¿Qué es core lightning?*** Hay tres implementaciones diferentes de Lightning en la actualidad: core lightning, LND y Eclair. Todos deben ser funcionalmente compatibles, basados ​​en las mismas [RFC de BOLT](https://github.com/lightningnetwork/lightning-rfc/blob/master/00-introduction.md), pero sus detalles de implementación pueden ser diferentes. Hemos elegido core lightning como base de nuestro curso porque también es parte del mismo [Elements Project](https://github.com/ElementsProject) que también contiene Libwally. -### Compilar el código fuente de c-lightning +### Compilar el código fuente de core lightning La instalación de Lightning desde el código fuente debería ser bastante simple si sigue estas instrucciones. _Probablemente_ desea hacer esto en un nodo sin podar, ya que trabajar con nodos podados en Lightning puede causar problemas con la instalación y el uso. Si configuró su nodo al principio de este curso para podarlo, es posible que desee reemplazarlo con un nodo sin podar ahora. (Si está usando testnet, debería poder usar el mismo tipo de máquina que usó para su nodo podado). -> :warning:**ADVERTENCIA:** En realidad, puede ejecutar c-lightning en un nodo podado. Sin embargo, como señala el [repositorio Lightning](https://github.com/ElementsProject/lightning#pruning), puede haber problemas. Para que funcione, debe asegurarse de que su nodo Lightning solo intente actualizar la información de los bloques que su nodo Bitcoin no ha eliminado. Para hacerlo, debe asegurarse de (1) que su nodo Bitcoin esté completamente actualizado antes de iniciar su nodo Lightning por primera vez; y (2) que su nodo Lightning nunca se quede muy atrás de su nodo Bitcoin (para una poda estándar de 550 bloques, nunca se puede apagar durante 4 o más días). Entonces, puede hacerlo, pero presenta cierto peligro, lo cual no es una buena idea si está ejecutando un servicio de producción. +> :warning:**ADVERTENCIA:** En realidad, puede ejecutar core lightning en un nodo podado. Sin embargo, como señala el [repositorio Lightning](https://github.com/ElementsProject/lightning#pruning), puede haber problemas. Para que funcione, debe asegurarse de que su nodo Lightning solo intente actualizar la información de los bloques que su nodo Bitcoin no ha eliminado. Para hacerlo, debe asegurarse de (1) que su nodo Bitcoin esté completamente actualizado antes de iniciar su nodo Lightning por primera vez; y (2) que su nodo Lightning nunca se quede muy atrás de su nodo Bitcoin (para una poda estándar de 550 bloques, nunca se puede apagar durante 4 o más días). Entonces, puede hacerlo, pero presenta cierto peligro, lo cual no es una buena idea si está ejecutando un servicio de producción. Con eso, está listo para instalar Lightning: @@ -87,7 +87,7 @@ Puede confirmar que ha instalado lightningd correctamente usando el parámetro ` Comenzará su exploración de la red Lightning con el comando `lightning-cli`. Sin embargo, `lightningd` _ debe_ estar ejecutándose para usar` lightning-cli`, ya que `lightning-cli` envía comandos JSON-RPC al` lightningd` (todo igual que con `bitcoin-cli` y` bitcoind`). -Si instaló `c-lightning` a mano, ahora deberá iniciarlo: +Si instaló `core lightning` a mano, ahora deberá iniciarlo: ``` $ nohup lightningd --testnet & @@ -199,13 +199,13 @@ bitcoin-cli -testnet getblock 0000000000000559febee77ab6e0be1b8d0bef0f971c7a4bee ## Crear alias -Sugerimos crear algunos alias para facilitar el uso de c-lightning. +Sugerimos crear algunos alias para facilitar el uso de core lightning. Puede hacerlo colocándolos en su `.bash_profile`. ``` cat >> ~/.bash_profile < :information_source: **NOTA:** Esta sección se ha agregado recientemente al curso y es un borrador inicial que aún puede estar pendiente de revisión. Lector de advertencias. Antes de comenzar a acceder a Lightning Network, debe comprender mejor su configuración. -## Conozca su directorio de c-lightning +## Conozca su directorio de core lightning -Cuando se usa c-lightning, todo se guarda en el directorio `~/.lightning`. +Cuando se usa core lightning, todo se guarda en el directorio `~/.lightning`. El directorio principal solo contiene directorios para las redes que estén configuradas, en este caso testnet: ``` diff --git a/es/19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md b/es/19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md index ccb841382..fd5acda8e 100644 --- a/es/19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md +++ b/es/19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md @@ -10,7 +10,7 @@ Hay cuatro maneras de hacerlo (las tres primeras son posibles para su primera co Si alguien más ya tiene un nodo Lightning en la red de su elección, simplemente pídale su ID. -Si están ejecutando c-lightning, solo necesitan usar el comando `getinfo`: +Si están ejecutando core lightning, solo necesitan usar el comando `getinfo`: ``` $ lightning-cli getinfo @@ -51,9 +51,9 @@ lightning-cli: WARNING: default network changing in 2020: please set network=tes ``` A continuación, pueden decirle su `id` (`03240a4878a9a64aea6c3921a434e573845267b86e89ab19003b0c910a86d17687`). También tendrán que indicarle su dirección IP (`74.207.240.32`) y su puerto (`9735`). -## Crear un nuevo nodo c-lightning +## Crear un nuevo nodo core lightning -Sin embargo, para fines de prueba, es probable que desee tener un segundo nodo bajo su propio control. La forma más fácil de hacerlo es crear un segundo nodo c-lightning en una máquina nueva, usando Bitcoin Standup, por [§2.1](02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md) o compilándolo a mano, por [§19.1](19_1_Verificando_Su_Configuracion_Lightning.md). +Sin embargo, para fines de prueba, es probable que desee tener un segundo nodo bajo su propio control. La forma más fácil de hacerlo es crear un segundo nodo core lightning en una máquina nueva, usando Bitcoin Standup, por [§2.1](02_1_Configurando_un_Bitcoin-Core_VPS_con_StackScript.md) o compilándolo a mano, por [§19.1](19_1_Verificando_Su_Configuracion_Lightning.md). Una vez que tenga su nodo en ejecución, puede ejecutar `getinfo` para recuperar su información, como se muestra arriba. @@ -109,7 +109,7 @@ $ sudo cp $GOPATH/bin/lnd $GOPATH/bin/lncli /usr/bin ``` ### Crear un archivo de configuración de LND -A diferencia de c-lightning, necesitará crear un archivo de configuración predeterminado para LND. +A diferencia de core lightning, necesitará crear un archivo de configuración predeterminado para LND. Sin embargo, usted primero necesita habilitar ZMQ en su Bitcoind, si no lo hizo ya en [§16.3](16_3_Recibiendo_Notificaciones_de_Bitcoind_en_C_con_las_Bibliotecas_ZMQ.md). @@ -211,7 +211,7 @@ $ sudo systemctl start lnd ### Habilitar conexiones remotas -Al igual que con c-lightning, va a tener que hacer LND accesible a otros nodos. He aquí cómo hacerlo si utiliza `ufw`, según las configuraciones de Bitcoin Standup: +Al igual que con core lightning, va a tener que hacer LND accesible a otros nodos. He aquí cómo hacerlo si utiliza `ufw`, según las configuraciones de Bitcoin Standup: ``` $ sudo ufw allow 9735 ``` @@ -315,10 +315,10 @@ Sin embargo, eso definitivamente no será el caso para su primera interacción c ## Resumen: Acceso a un segundo nodo de rayos -Siempre necesitará dos nodos Lightning para formar un canal. Si no tiene a alguien más que esté probando las cosas con usted, va a necesitar crear un segundo nodo, ya sea usando c-lightning o (como haremos en nuestros ejemplos) LND. +Siempre necesitará dos nodos Lightning para formar un canal. Si no tiene a alguien más que esté probando las cosas con usted, va a necesitar crear un segundo nodo, ya sea usando core lightning o (como haremos en nuestros ejemplos) LND. ## ¿Qué es lo siguiente? -Aunque posiblemente haya creado un LND, c-lightning seguirá siendo el corazón de nuestros ejemplos hasta que necesitemos empezar a usar ambos, en el [Capítulo 19](19_0_Entendiendo_Su_Configuracion_Lightning.md). +Aunque posiblemente haya creado un LND, core lightning seguirá siendo el corazón de nuestros ejemplos hasta que necesitemos empezar a usar ambos, en el [Capítulo 19](19_0_Entendiendo_Su_Configuracion_Lightning.md). Continuar "Comprender la configuración de nodo Lightning" con [§19.3: Creando un Canal en Lightning](19_3_Creando_un_Canal_en_Lightning.md). diff --git a/es/19_3_Creando_un_Canal_en_Lightning.md b/es/19_3_Creando_un_Canal_en_Lightning.md index 23992d8da..f97dca72e 100644 --- a/es/19_3_Creando_un_Canal_en_Lightning.md +++ b/es/19_3_Creando_un_Canal_en_Lightning.md @@ -2,29 +2,29 @@ > :information_source: **NOTA:** Esta sección se agregó recientemente al curso y es un borrador inicial que aún puede estar pendiente de revisión. Lector de advertencias. -Ahora comprende los conceptos básicos de su configuración Lightning y, con suerte, ha creado o recibido información sobre un segundo nodo Lightning. Está listo para crear su primer canal Lightning Network. Por supuesto, deberá comprender qué es y cómo se crea utilizando c-lightning. +Ahora comprende los conceptos básicos de su configuración Lightning y, con suerte, ha creado o recibido información sobre un segundo nodo Lightning. Está listo para crear su primer canal Lightning Network. Por supuesto, deberá comprender qué es y cómo se crea utilizando core lightning. > :book: ***¿Qué es un canal de lightning?*** Simplemente, un canal de iluminación es un tubo de dinero que permite transferencias de dinero rápidas, baratas y privadas sin enviar transacciones a la cadena de bloques. Más técnicamente, un canal es una transacción de Bitcoin en cadena con firmas múltiples 2 de 2 que establece una relación financiera sin confianza entre dos personas o dos agentes. Se deposita una cierta cantidad de dinero en el canal, cuando luego se mantiene una base de datos local con saldo de bitcoins para ambas partes, haciendo un seguimiento de cuánto dinero tiene cada uno de la cantidad inicial. Los dos usuarios pueden intercambiar bitcoins a través de su canal Lightning sin tener que escribir en la cadena de bloques de Bitcoin. Solo cuando quieren cerrar su canal, liquidan sus bitcoins en la cadena de bloques, en función de la división final de monedas. > :book: ***¿Cómo crean los canales Lightning una red Lightning?*** Aunque un canal Lightning solo permite el pago entre dos usuarios, los canales se pueden conectar entre sí para formar una red que permite pagos entre miembros que no tienen canal directo entre ellos. Esto crea una red entre varias personas construida a partir de conexiones por pares. -En esta sección, continuaremos usando nuestra configuración de c-lightning como nuestro nodo principal. +En esta sección, continuaremos usando nuestra configuración de core lightning como nuestro nodo principal. ## Crear un canal La creación de un canal Lightning requiere los siguientes pasos: -* Financie su billetera c-lightning con algunos satoshis. +* Financie su billetera core lightning con algunos satoshis. * Conéctese a un nodo remoto como un par. * Abre un canal. -### Financiar su billetera c-lightning +### Financiar su billetera core lightning -Para mover fondos a un canal Lightning, primero se requiere financiar su billetera c-lightning. +Para mover fondos a un canal Lightning, primero se requiere financiar su billetera core lightning. -> :book: ***¿Qué es una billetera c-lightning?*** La implementación estándar de C-lightning viene con una billetera Bitcoin integrada que le permite enviar y recibir transacciones bitcoin en cadena. Esta billetera se utilizará para crear nuevos canales. +> :book: ***¿Qué es una billetera core lightning?*** La implementación estándar de core lightning viene con una billetera Bitcoin integrada que le permite enviar y recibir transacciones bitcoin en cadena. Esta billetera se utilizará para crear nuevos canales. -Lo primero que debe hacer es enviar algunos satoshis a su billetera c-lightning. Puede crear una nueva dirección usando el comando `lightning-cli newaddr`. Esto genera una nueva dirección que posteriormente se puede utilizar para financiar canales gestionados por el nodo c-lightning. Puede especificar el tipo de dirección deseada; si no se especifica, la dirección generada será un bech32. +Lo primero que debe hacer es enviar algunos satoshis a su billetera core lightning. Puede crear una nueva dirección usando el comando `lightning-cli newaddr`. Esto genera una nueva dirección que posteriormente se puede utilizar para financiar canales gestionados por el nodo core lightning. Puede especificar el tipo de dirección deseada; si no se especifica, la dirección generada será un bech32. ``` $ lightning-cli --testnet newaddr @@ -76,15 +76,15 @@ Tenga en cuenta que el valor aparece en satoshis o microsatoshis, ¡no en Bitcoi > :book: ***¿Qué son los satoshis y msat?*** Ya conoció los satoshis en [§3.4](03_4_Recibiendo_una_Transaccion.md). Un satoshi es la cien millonésima parte de un bitcoin, por lo que 300.000 satoshi = 0,003 BTC. Un satoshi es la unidad monetaria más pequeña de la red Bitcoin. Pero, la red Lightning puede ser más pequeña, por lo que 1000 msat, o milisatoshis, equivalen a un satoshi. Eso significa que 1 msat es la cien mil millonésima parte de un bitcoin y 300.000.000 msat = 0,003 BTC. -Ahora que ha financiado su billetera c-lightning, necesitará información sobre un nodo remoto para comenzar a crear el proceso de canal. +Ahora que ha financiado su billetera core lightning, necesitará información sobre un nodo remoto para comenzar a crear el proceso de canal. ### Conectarse a un nodo remoto Lo siguiente que debe hacer es conectar su nodo a un par. Esto se hace con el comando `lightning-cli connect`. Recuerde que si desea obtener más información sobre este comando, debe escribir `lightning-cli help connect`. -Para conectar su nodo a un par remoto, necesita su ID, que representa la clave pública del nodo de destino. Para su comodidad, `id` puede tener el formato `id@host` o `id@host:port`. Es posible que haya recuperado esto con `lightning-cli getinfo` (en c-lightning) o `lncli --network=testnet getinfo` (en LND) como se discutió en el [interludio anterior](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md). +Para conectar su nodo a un par remoto, necesita su ID, que representa la clave pública del nodo de destino. Para su comodidad, `id` puede tener el formato `id@host` o `id@host:port`. Es posible que haya recuperado esto con `lightning-cli getinfo` (en core lightning) o `lncli --network=testnet getinfo` (en LND) como se discutió en el [interludio anterior](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md). -Hemos seleccionado el nodo LND, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, que se encuentra en la dirección IP `45.33.35.151`, a la que nos vamos a conectar desde nuestro nodo c-lightning: +Hemos seleccionado el nodo LND, `032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543`, que se encuentra en la dirección IP `45.33.35.151`, a la que nos vamos a conectar desde nuestro nodo core lightning: ``` $ lightning-cli --network=testnet connect 032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543@45.33.35.151 diff --git a/es/20_1_Generando_una_Solicitud_de_Pago.md b/es/20_1_Generando_una_Solicitud_de_Pago.md index 6e778740d..e96d57f7e 100644 --- a/es/20_1_Generando_una_Solicitud_de_Pago.md +++ b/es/20_1_Generando_una_Solicitud_de_Pago.md @@ -3,15 +3,15 @@ > :information_source: **NOTA:** Esta sección se ha agregado recientemente al curso y es un borrador inicial que aún puede estar pendiente de revisión. Lector de advertencias. -Esta sección describe cómo funcionan los pagos en Lightning Network, cómo crear una solicitud de pago (o _factura_), y, finalmente, cómo entenderla. Le emisión de facturas depende de que tenga un segundo nodo Lightning, como se describe en [Acceso a un Segundo Nodo Lightning](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md). Estos ejemplos usarán un nodo LND como su nodo secundario, para demostrar aún más las posibilidades de Lightning Network. Para diferenciar entre los nodos en estos ejemplos, las solicitudes se mostrarán como `c$` para el nodo c-lightning y `lnd$` como el nodo LND. Si desea reproducir estos pasos, debe [instalar su propio nodo LND secundario](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md#Crear-un-nuevo-nodo-LND). +Esta sección describe cómo funcionan los pagos en Lightning Network, cómo crear una solicitud de pago (o _factura_), y, finalmente, cómo entenderla. Le emisión de facturas depende de que tenga un segundo nodo Lightning, como se describe en [Acceso a un Segundo Nodo Lightning](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md). Estos ejemplos usarán un nodo LND como su nodo secundario, para demostrar aún más las posibilidades de Lightning Network. Para diferenciar entre los nodos en estos ejemplos, las solicitudes se mostrarán como `c$` para el nodo core lightning y `lnd$` como el nodo LND. Si desea reproducir estos pasos, debe [instalar su propio nodo LND secundario](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md#Crear-un-nuevo-nodo-LND). > :book: ***¿Qué es una Factura?** Casi todos los pagos realizados en Lightning Network requieren una factura, que no es más que una **solicitud de pago** realizada por el destinatario del dinero y enviada por una variedad de medios al usario que paga. Todas las solicitudes de pago son de un solo uso. Las facturas Lightning utilizan la codificación bech32, que ya utiliza Segregated Witness para Bitcoin. ## Crear una Factura -Para crear una nueva factura en c-lightning, usaría el comando `lightning-cli --testnet invoice`. +Para crear una nueva factura en core lightning, usaría el comando `lightning-cli --testnet invoice`. -Así es como funcionaría con c-lightning, usando argumentos de una cantidad (en millisatoshis), una etiqueta y una descripción. +Así es como funcionaría con core lightning, usando argumentos de una cantidad (en millisatoshis), una etiqueta y una descripción. ``` c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for dinner" { @@ -22,7 +22,7 @@ c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for "warning_mpp_capacity": "The total incoming capacity is still insufficient even if the payer had MPP capability." } ``` -Sin embargo, para este ejemplo, vamos a generar una factura en un nodo LND y luego pagarla en el nodo c-lightning. Esto requiere el comando `addinvoice` ligeramente diferente de LND. Puede usar el argumento `--amt` para indicar la cantidad a pagar (en millisatoshis) y agregar una descripción usando el argumento `--memo`. +Sin embargo, para este ejemplo, vamos a generar una factura en un nodo LND y luego pagarla en el nodo core lightning. Esto requiere el comando `addinvoice` ligeramente diferente de LND. Puede usar el argumento `--amt` para indicar la cantidad a pagar (en millisatoshis) y agregar una descripción usando el argumento `--memo`. ``` lnd$ lncli -n testnet addinvoice --amt 10000 --memo "First LN Payment - Learning Bitcoin and Lightning from the Command line." @@ -64,7 +64,7 @@ La parte legible por humanos `ln` + `tb` + `100u`. ### Leer la Parte de la Factura de Datos -El resto de la factura (`1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd`) contiene una marca de tiempo, datos etiquetados específicamente y una firma. Obviamente, no puede leerlo usted mismo, pero puede pedirle a `lightning-cli` de c-lightning que lo haga con el comando `decodepay`: +El resto de la factura (`1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd`) contiene una marca de tiempo, datos etiquetados específicamente y una firma. Obviamente, no puede leerlo usted mismo, pero puede pedirle a `lightning-cli` de core lightning que lo haga con el comando `decodepay`: ``` c$ lightning-cli --testnet decodepay lntb100u1p0cwnqtpp5djkdahy4hz0wc909y39ap9tm3rq2kk9320hw2jtntwv4x39uz6asdr5ge5hyum5ypxyugzsv9uk6etwwssz6gzvv4shymnfdenjqsnfw33k76twypskuepqf35kw6r5de5kueeqveex7mfqw35x2gzrdakk6ctwvssxc6twv5hqcqzpgsp5a9ryqw7t23myn9psd36ra5alzvp6lzhxua58609teslwqmdljpxs9qy9qsq9ee7h500jazef6c306psr0ncru469zgyr2m2h32c6ser28vrvh5j4q23c073xsvmjwgv9wtk2q7j6pj09fn53v2vkrdkgsjv7njh9aqqtjn3vd { diff --git a/es/20_3_Cerrando_un_Canal_Lightning.md b/es/20_3_Cerrando_un_Canal_Lightning.md index 926ab5c6f..f407ba9a4 100644 --- a/es/20_3_Cerrando_un_Canal_Lightning.md +++ b/es/20_3_Cerrando_un_Canal_Lightning.md @@ -178,7 +178,7 @@ $ bitcoin-cli --named getrawtransaction txid=f68de52d80a1076e36c677ef640539c50e3 "blocktime": 1602713519 } ``` -La entrada de la transacción es `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, que era la transacción de financiación en [§19.3](19_3_Creando_un_Canal_en_Lightning.md). La transacción tiene dos salidas, una para el nodo remoto y la otra para la billetera c-lightning local. La salida en el índice 0 corresponde al nodo remoto con un valor de 0.00010012 BTC; y la salida en el índice 1 corresponde al nodo local con un valor de 0.00089804 BTC. +La entrada de la transacción es `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, que era la transacción de financiación en [§19.3](19_3_Creando_un_Canal_en_Lightning.md). La transacción tiene dos salidas, una para el nodo remoto y la otra para la billetera core lightning local. La salida en el índice 0 corresponde al nodo remoto con un valor de 0.00010012 BTC; y la salida en el índice 1 corresponde al nodo local con un valor de 0.00089804 BTC. Lightning mostrará de manera similar 89804 satoshis devueltos como un nuevo UTXO en su billetera: ``` diff --git a/es/20_4_Expandiendo_la_Red_Lightning.md b/es/20_4_Expandiendo_la_Red_Lightning.md index 1fd125c28..84396d0bd 100644 --- a/es/20_4_Expandiendo_la_Red_Lightning.md +++ b/es/20_4_Expandiendo_la_Red_Lightning.md @@ -4,9 +4,9 @@ Estos dos capítulos han cubierto solo algunas de las actividades más importantes con Lightning. Se puede hacer mucho más y es posible una gran variedad. Lo que sigue son algunos consejos a seguir. -## Usar Complementos de c-lightning +## Usar Complementos de core lightning -c-lightning es una implementación ligera, altamente pseronalizable y compatible con el estándar del protocolo de la Red Lightning. Extiende su funcionalidad usando complementos. Principalmente, estos son subprocesos que son inciados por el demonio `lightningd` y pueden interactuar con `lightningd` en una variedad de formas: +core lightning es una implementación ligera, altamente pseronalizable y compatible con el estándar del protocolo de la Red Lightning. Extiende su funcionalidad usando complementos. Principalmente, estos son subprocesos que son inciados por el demonio `lightningd` y pueden interactuar con `lightningd` en una variedad de formas: * Las opciones de la línea de comandos permiten que los complementos registren sus propios argumentos de línea de comandos, que luego se exponen a través de `lightningd`. * El paso de comandos JSON-RPC permite que los complementos agreguen sus propios comandos a la interfaz JSON-RPC. @@ -19,19 +19,19 @@ El repositorio de GitHub `lightningd` mantiene una lista actualizada de [complem ## Usar Carteras Móviles -Actualmente conocemos dos billeteras Lightning móviles que admiten la implementación de c-lightning. +Actualmente conocemos dos billeteras Lightning móviles que admiten la implementación de core lightning. Para dispositivos iOS, FullyNoded es una billetera de Bitcoin para iOS de código abierto que se conecta a través del servicio autenticado Tor V3 a su propio nodo completo. La funcionalidad FullyNoded se encuentra actualmente en desarrolo activo y en la fase de prueba beta inicial. * [FullyNoded](https://github.com/Fonta1n3/FullyNoded/blob/master/Docs/Lightning.md) -SparkWallet es una GUI de billetera minimalista para c-lightning, accesible a través de la web o mediante aplicaciones móviles y de escritorio para Android. +SparkWallet es una GUI de billetera minimalista para core lightning, accesible a través de la web o mediante aplicaciones móviles y de escritorio para Android. * [SparkWallet](https://github.com/shesek/spark-wallet) ## Usar Differentes Implementaciones Lightning -c-lightning no es su única opción. Hoy en día existen tres implementaciones ampliamente utilizadas de la Red Network. Todos siguen los [documentos Basis of Lightning Technology (BOLT)](https://github.com/lightningnetwork/lightning-rfc), (la base de la tecnología lightning) que describen un protocolo de layer-2 para transferencias de bitcoins fuera de la cadena. Las especificaciones son actualmente un trabajo en progreso que aún se está redactando. +core lightning no es su única opción. Hoy en día existen tres implementaciones ampliamente utilizadas de la Red Network. Todos siguen los [documentos Basis of Lightning Technology (BOLT)](https://github.com/lightningnetwork/lightning-rfc), (la base de la tecnología lightning) que describen un protocolo de layer-2 para transferencias de bitcoins fuera de la cadena. Las especificaciones son actualmente un trabajo en progreso que aún se está redactando. | Nombre | Descripción | BitcoinStandup | Lenguaje | Repositorio | | ------------- | ------------- | :---: | ------------- | ------------- | diff --git a/es/README.md b/es/README.md index ae755fce7..044e5572d 100644 --- a/es/README.md +++ b/es/README.md @@ -135,8 +135,8 @@ Si le gustaría hacer su propia traducción, por favor, vea [Contribuyendo](#con **Estado:** Finalizado. * [19.0: Entendiendo Su Configuración Lightning](19_0_Entendiendo_Su_Configuracion_Lightning.md) - * [19.1: Verificando Su Configuración c-lightning](19_1_Verificando_Su_Configuracion_Lightning.md) - * [19.2: Conociendo Su Configuración c-lightning](19_2_Conociendo_Su_Configuracion_Lightning.md) + * [19.1: Verificando Su Configuración core lightning](19_1_Verificando_Su_Configuracion_Lightning.md) + * [19.2: Conociendo Su Configuración core lightning](19_2_Conociendo_Su_Configuracion_Lightning.md) * [Interludio: Accediendo a un Segundo Nodo Lightning](19_2_Interludio_Accediendo_a_un_Segundo_Nodo_Lightning.md) * [19.3: Creando un Canal en Lightning](19_3_Creando_un_Canal_en_Lightning.md) * [20.0: Usando Lightning](20_0_Usando_Lightning.md) diff --git a/it/01_0_Introduzione.md b/it/01_0_Introduzione.md index a1379e988..4d41bd68b 100644 --- a/it/01_0_Introduzione.md +++ b/it/01_0_Introduzione.md @@ -37,11 +37,11 @@ Da dove si comincia? Questo libro è stato pensato per essere letto in sequenza. Se avete diversi livelli di abilità o volete imparare cose diverse, potete passare a parti diverse del libro: -* Se si dispone già di un ambiente Bitcoin pronto per essere utilizzato, passa a [Capitolo Tre: Comprendere le Configurazioni di Bitcoin](03_0_Comprendere_le_Configurazioni_di_Bitcoin.md). +* Se si dispone già di un ambiente Bitcoin pronto per essere utilizzato, passa a [Capitolo Tre: Comprendere le Configurazioni di Bitcoin](03_0_Comprendere_la_Configurazione_di_Bitcoin.md). * Se vi interessa solo lo scripting di Bitcoin, passate a [Capitolo Nove: Introduzione script di Bitcoin](09_0_Introduzione_script_di_Bitcoin.md). -* Se volete solo leggere dell'uso dei linguaggi di programmazione, saltate a [Capitolo Sedici: Parlare con Bitcoind](16_0_Parlare_con_Bitcoind.md). +* Se volete solo leggere dell'uso dei linguaggi di programmazione, saltate a [Capitolo Sedici: Parlare con Bitcoind](16_0_Parlare_a_Bitcoind_con_C.md). * Se invece non volete fare programmazione, saltate assolutamente i capitoli 15-17 durante la lettura e forse anche i capitoli 9-13. Il resto del corso dovrebbe avere senso anche senza di essi. -* Se siete interessati solo a Lightning, fate un salto su [Capitolo dicianove: Comprendere La Configurazione Lightning](19_0_Comprendere_La_Configurazione_Lightning.md). +* Se siete interessati solo a Lightning, fate un salto su [Capitolo dicianove: Comprendere La Configurazione Lightning](19_0_Comprendere_la_Configurazione_Lightning.md). * Se volete leggere i nuovi contenuti principali aggiunti per la v2 del corso (2020), dopo la v1 (2017), leggete: [Capitolo 3.5: Comprendere il Descriptor](03_5_Comprendere_il_Descriptor.md) [Capitolo 4.6: Creare una Transazione Segwit](04_6_Creare_una_Transazione_Segwit.md) @@ -50,7 +50,7 @@ Se avete diversi livelli di abilità o volete imparare cose diverse, potete pass [Capitolo 10.5: Programmare uno Script Segwit](10_5_Programmare_uno_Script_Segwit.md) [Capitolo 14: Usare Tor](14_0_Usare_Tor.md) [Capitolo 15: Usare i2p](15_0_Usare_i2p.md) - [Capitolo 16: Parlare con Bitcoind](16_0_Parlare_con_Bitcoind.md) + [Capitolo 16: Parlare con Bitcoind](16_0_Parlare_a_Bitcoind_con_C.md) [Capitolo 17: Programmare Bitcoin con Libwally](17_0_Programmare_Bitcoin_con_Libwally.md) [Capitolo 18: Parlare a Bitcoind in Altri Linguaggi](18_0_Parlare_a_Bitcoind_in_Altri_Linguaggi.md) [Capitolo 19: Comprendere la Configurazione Lightning](19_0_Comprendere_la_Configurazione_Lightning.md) diff --git a/it/02_1_Configurare_Bitcoin-Core_VPS_con_StackScript.md b/it/02_1_Configurare_Bitcoin-Core_VPS_con_StackScript.md index 205593fec..70bb1ab02 100644 --- a/it/02_1_Configurare_Bitcoin-Core_VPS_con_StackScript.md +++ b/it/02_1_Configurare_Bitcoin-Core_VPS_con_StackScript.md @@ -1,6 +1,6 @@ # 2.1: Configurando Bitcoin-Core VPS con StackScript -Questo documento spiega come configurare un VPS (Virtual Private Sever) per avviare un nodo Bitcoin su Linode.com, installato utilizzando uno StackScript automatizzato del [Progetto Bitcoin Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). Devi solo inserire alcuni comandi e avviare il tuo VPS. Quasi subito dopo l'avvio, scoprirai che il tuo nuovo nodo Bitcoin scarica i blocchi. +Questo documento spiega come configurare un VPS (Virtual Private Sever) per avviare un nodo Bitcoin su Linode.com utilizzando uno StackScript automatizzato del [Progetto Bitcoin Standup](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). Devi solo inserire alcuni comandi e avviare il tuo VPS. Quasi subito dopo l'avvio, scoprirai che il tuo nuovo nodo Bitcoin scarica i blocchi. > :warning: **Pericolo:** Non utilizzare un VPS per un portafoglio bitcoin con fondi reali significativi; Vedere [Perdere facilmente Bitcoin](http://blog.thestateofme.com/2012/03/03/lessons-to-be-learned-from-the-linode-bitcoin-incident/ ). È molto bello poter sperimentare con transazioni bitcoin reali su un nodo live senza vincolare un server proprio su una rete locale. È anche utile essere in grado di utilizzare un iPhone o un iPad per comunicare tramite SSH con il tuo VPS per svolgere alcune semplici attività bitcoin. Ma è necessario un livello di sicurezza più elevato per fondi significativi. @@ -11,9 +11,9 @@ Questo documento spiega come configurare un VPS (Virtual Private Sever) per avvi ## Iniziare con Linode -Linode è un servizio di Cloud Hosting che offre server Linux veloci ed economici con archiviazione SSD. Li usiamo per questo tutorial principalmente perché i loro StackScripts basati su BASH offrono un modo semplice per configurare automaticamente un nodo Bitcoin senza problemi. +Linode (adesso Akamai Cloud) è un servizio di Cloud Hosting che offre server Linux veloci ed economici con archiviazione SSD. Li usiamo per questo tutorial principalmente perché i loro StackScripts basati su BASH offrono un modo semplice per configurare automaticamente un nodo Bitcoin senza problemi. -### Configurando un account Linode +### Configurare un account Linode Vai a questo link per creare un account Linode: @@ -28,92 +28,74 @@ Dovrai fornire un indirizzo email e successivamente precaricare denaro da una ca https://www.linode.com/?r=23211828bc517e2cb36e0ca81b91cc8c0e1b2d96 ``` -Quando avrai finito, dovresti arrivare a [https://cloud.linode.com/dashboard](https://cloud.linode.com/dashboard). +Quando avrai finito, dovresti arrivare a [https://cloud.linode.com/linodes](https://cloud.linode.com/linodes). ### Considera abilitare la autenticazione a 2 fattori (Two-Factor Authentication) -Il tuo server non sara al sicuro se le persone riescono ad accedere al tuo account Linode, quindi valuta la possibilità di impostare l'autenticazione a due fattori per questo. Puoi trovare questa impostazione nella tua pagina [Il mio profilo: password e autenticazione](https://manager.linode.com/profile/auth). Se non lo fai adesso, imposta un promemoria e fallo più tardi. +Il tuo server non sara al sicuro se le persone riescono ad accedere al tuo account Linode, quindi valuta la possibilità di impostare l'autenticazione a due fattori per questo. Puoi trovare questa impostazione nella tua pagina [Il mio profilo: password e autenticazione](https://cloud.linode.com/profile/auth). Se non lo fai adesso, imposta un promemoria e fallo più tardi. ## Crea una immmagine Linode utilizando StackScript ### Carica lo StackScript -Scarica [Linode Standup Script](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) da [Bitcoin Standup Scripts repo](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). Questo script sostanzialmente automatizza tutte le istruzioni di configurazione di Bitcoin VPS. Se vuoi essere particolarmente prudente, leggilo attentamente. Se sei soddisfatto, puoi copiare StackScript nel tuo account andando alla [pagina StackScripts](https://cloud.linode.com/stackscripts?type=account) nel tuo account Linode account e scegliere [Crea Nuovo Stackscript](https://cloud.linode.com/stackscripts/create). Dategli un nome (noi usiamo `Bitcoin Standup`), poi copia e incolla lo script. Scegli Debian 10 come immagine di destinazione e "Salva".. +Scarica [Linode Standup Script](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts/blob/master/Scripts/LinodeStandUp.sh) da [Bitcoin Standup Scripts repo](https://github.com/BlockchainCommons/Bitcoin-Standup-Scripts). Questo script sostanzialmente automatizza tutte le istruzioni di configurazione di Bitcoin VPS. Se vuoi essere particolarmente prudente, leggilo attentamente. Se sei soddisfatto, puoi copiare StackScript nel tuo account andando alla [pagina StackScripts](https://cloud.linode.com/stackscripts) nel tuo account Linode account e scegliere [Crea Nuovo Stackscript](https://cloud.linode.com/stackscripts/create). Dategli un nome (noi usiamo `Bitcoin Standup`), poi copia e incolla lo script. Scegli Debian 13 come immagine di destinazione e "Salva".. ### Configurazione iniziale Ora sei pronto per creare un Nodo basato su Stackscript. 1. Nella pagina [Stackscripts page](https://cloud.linode.com/stackscripts?type=account), clicca i tre puntini "..." nella parte destra del tuo nuovo script e seleziona "Deploy New Linode". -2. Inserisci un nome host breve e attinente +2. Immettere la password per l'utente "standup". Questo sarà l'utente che esegue ```bitcoind```. +3. Inserisci un nome host breve e attinente * **Nome host breve.** Scegli un nome per il tuo VPS. Ad esempio, "mybtctest". * **Nome host completo.** Se hai intenzione di includere questo VPS come parte di una rete con record DNS completi, digita il nome host con il suo dominio. Ad esempio, "mybtctest.mydomain.com". Altrimenti, ripeti semplicemente il nome host breve e aggiungi ".local", ad esempio "mybtctest.local". -3. Immettere la password per l'utente "standup". 4. Scegli un tipo di installazione nelle opzioni avanzate. * **Tipo di installazione.** Probabilmente è "Mainnet" o "Pruned Mainnet" se stai impostando un nodo per l'utilizzo e "Testnet" o "Pruned Testnet" se stai solo giocando. La maggior parte di questo tutorial darà per scontato che tu abbia scelto "Pruned Testnet", ma dovresti comunque essere in grado di seguire altri tipi. Consulta la [Sinossi](#sinossi-tipi-di-installazione-di-bitcoin) per maggiori informazioni su queste opzioni. (Nota che se hai intenzione di provare i capitoli Lightning, probabilmente vorrai usare un nodo Unpruned, non potato, poiché lavorare con nodi Pruned su Lightning è incerto. Consulta [Capitolo 19](19_0_Comprendere_La_Configurazione_Lightning.md) per i dettagli.) - - - - -* **Chiave pubblica X25519.** Questa è una chiave pubblica da aggiungere all'elenco dei client autorizzati di Tor. Se non la usi, chiunque ottenga il codice QR per il tuo nodo può accedervi. Otterrai questa chiave pubblica da qualsiasi client tu stia utilizzando per connetterti al tuo nodo. Ad esempio, se utilizzi [FullyNoded 2](https://github.com/BlockchainCommons/FullyNoded-2), puoi andare alle sue impostazioni e "Esporta chiave pubblica di autenticazione Tor V3" per utilizzarla qui. -* **Chiave SSH.** Copia qui la chiave SSH del tuo computer locale; questo ti consente di accedere automaticamente tramite SSH all'account standup. Se non hai ancora impostato una chiave SSH sul tuo computer locale, ci sono delle buone istruzioni su [Github](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/). Potresti anche voler aggiungere la tua chiave SSH nel tuo Linode LISH (Linode Interactive Shell) andando su "Linode Home Page / My Preferences / LISH Settings / LISH Keys". L'utilizzo di una chiave SSH ti darà un modo più semplice e sicuro per accedere al tuo server. -* **IP consentiti tramite SSH.** Questo è un elenco separato da virgole di IP a cui sarà consentito l'accesso tramite SSH al VPS. Ad esempio "192.168.1.15,192.168.1.16". Se non inserisci alcun IP, _il tuo VPS non sarà molto sicuro_. Sarà costantemente bombardato da aggressori che cercheranno di entrare e potrebbero anche riuscirci. - -5. Select an Image - * **Target Image.** If you followed the instructions, this will only allow you to select "Debian 10" (though "Debian 9" did also work with previous versions of this Stackscript and might still). -6. Choose a region for where the Linode will be located. - -*The remaining questions all have to do with the mechanics of the VPS deployment and should be left as they are with one exception: bump the Swap Disk from 256MB to 512MB, to ensure that you have enough memory to download the blockchain._ - -Finally, you'll need to fill in a root password, which will be the password used for the root account. - - - - -5. Seleziona un'immagine +* **Timezone.** Il timezone della tua macchine. +* **Sicurezza: Chiave pubblica Tor X25519.** Questa è una chiave pubblica da aggiungere all'elenco dei client autorizzati di Tor. Se non la usi, chiunque ottenga il codice QR per il tuo nodo può accedervi. Otterrai questa chiave pubblica da qualsiasi client tu stia utilizzando per connetterti al tuo nodo. Ad esempio, se utilizzi [FullyNoded 2](https://github.com/BlockchainCommons/FullyNoded-2), puoi andare alle sue impostazioni e "Esporta chiave pubblica di autenticazione Tor V3" per utilizzarla qui. +* **Sicurezza: Chiave SSH Standup.** Copia qui la chiave SSH del tuo computer locale; questo ti consente di accedere automaticamente tramite SSH all'account standup. Se non hai ancora impostato una chiave SSH sul tuo computer locale, ci sono delle buone istruzioni su [Github](https://help.github.com/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent/). Potresti anche voler aggiungere la tua chiave SSH nel tuo Linode LISH (Linode Interactive Shell) andando su "Linode Home Page / My Preferences / LISH Settings / LISH Keys". L'utilizzo di una chiave SSH ti darà un modo più semplice e sicuro per accedere al tuo server. +* **Sicurezza: IP consentiti tramite SSH.** Questo è un elenco separato da virgole di IP a cui sarà consentito l'accesso tramite SSH al VPS. Ad esempio "192.168.1.15,192.168.1.16". Se non inserisci alcun IP, _il tuo VPS non sarà molto sicuro_. Sarà costantemente bombardato da aggressori che cercheranno di entrare e potrebbero anche riuscirci. +* **Cypherpunkpay.** Queste sono opzioni per installare Cypherpunkpay sul tuo server. Sono intese principalmente per altri utenti dello Standup software e non sono usati in questo corso, così li puoi lasciare cosi come sono. + +5. Scegli una regione in cui verrà posizionato Linode. +6. Seleziona un'immagine * **Immagine di destinazione.** Se hai seguito le istruzioni, questo ti consentirà di selezionare solo "Debian 10" (anche se "Debian 9" funzionava con le versioni precedenti di questo Stackscript, potrebbe ancora funzionare). -6. Scegli una regione in cui verrà posizionato Linode. - -*Le domande rimanenti riguardano tutte la meccanica della distribuzione VPS e dovrebbero essere lasciate così come sono, con un'eccezione: aumenta lo Swap Disk da 256 MB a 512 MB, per assicurarti di avere abbastanza memoria per scaricare la blockchain._ - -Infine, dovrai inserire una password di root, che sarà la password utilizzata per l'account root. - -### Scegli altre opzioni di Standup - -Blockchain Commons è attualmente impegnata ad ampliare i suoi Bitcoin Standup Scripts con opzioni per installare Lightning e altre app Bitcoin degne di nota. Dai un'occhiata a tutte le opzioni extra e vedi se sono cose con cui ti piacerebbe giocare. In particolare, se Lightning è un'opzione, ti consigliamo di installarla, perché renderà molto più semplici [Capitolo 19](19_0_Comprendere_La_Configurazione_Lightning.md) e [Capitolo 20](20_0_Usare_Lightning.md). - ### Scegli un piano Linode Dovrai scegliere un piano Linode. -Un Linode da 4 GB sarà sufficiente per la maggior parte delle configurazioni, tra cui: Pruned Mainnet, Pruned Testnet e persino non-Pruned Testnet. Tutte utilizzano meno di 50 GB di spazio di archiviazione e 4 GB sono una quantità di memoria confortevole. Questa è la configurazione che suggeriamo. Costa $ 20 al mese. +Un Linode da 4 GB sarà sufficiente per la maggior parte delle configurazioni, tra cui: Pruned Mainnet, Pruned Testnet, Pruned Signet e persino non-Pruned Signet. Tutte utilizzano meno di 50 GB di spazio di archiviazione e 4 GB sono una quantità di memoria confortevole. Questa è la configurazione che suggeriamo. Costa $ 20 al mese. -Se invece desideri avere una Mainnet non-Pruned in un VPS, dovrai installare un Linode con un disco superiore a 800 G (!), che attualmente è il Linode da 16 GB, che ha 320 G di spazio di archiviazione e 16 G di memoria e costa circa $ 80 al mese. Noi _non_ lo consigliamo. +Se invece desideri avere una Mainnet non-Pruned in un VPS, dovrai installare un Linode con un disco superiore a 715G(!), che attualmente è il Linode da 64 GB, che ha 1280G di spazio di archiviazione e 64G di memoria e costa circa $ 348 al mese. Noi _non_ lo consigliamo. (Ma vedi sotto per le alternative) La seguente tabella mostra i requisiti minimi | Setup | Memory | Storage | Linnode | |-------|--------|---------|---------| -| Mainnet | 2G | 280G | Linode 16GB | +| Mainnet | 2G | ~715G | Linode 64GB | | Pruned Mainnet | 2G | ~5G | Linode 4GB | -| Testnet | 2G | ~15G | Linode 4GB | +| Signet | 2G | ~15G | Linode 4GB | +| Pruned Signet | 2G | ~5G | Linode 4GB | +| Testnet | 2G | ~15G | Linode 16GB | | Pruned Testnet | 2G | ~5G | Linode 4GB | | Regtest | 2G | ~ | Linode 4GB | Nota, potrebbero esserci modi per ridurre entrambi i costi. -* Per le macchine che suggeriamo come **Linode 4 GB**, potresti essere in grado di ridurle a un Linode 2 GB. Alcune versioni di Bitcoin Core hanno funzionato bene a quella dimensione, alcune hanno occasionalmente esaurito la memoria e poi si sono riprese, e alcune hanno esaurito continuamente la memoria. Ricordati di aumentare quello spazio di swap per massimizzare le probabilità che funzioni. Usalo a tuo rischio e pericolo. +* Per i setup che suggeriamo come **Linode 4 GB**, potresti essere in grado di ridurle a un Linode 2 GB. Alcune versioni di Bitcoin Core hanno funzionato bene a quella dimensione, alcune hanno occasionalmente esaurito la memoria e poi si sono riprese, e alcune hanno esaurito continuamente la memoria. Ricordati di aumentare quello spazio di swap per massimizzare le probabilità che funzioni. Usalo a tuo rischio e pericolo. * Per la Mainnet non potata, che suggeriamo come **Linode 16 GB**, probabilmente puoi cavartela con un Linode 4 GB, ma aggiungi [Block Storage](https://cloud.linode.com/volumes) sufficiente per archiviare la blockchain. Questa è sicuramente una soluzione migliore a lungo termine poiché i requisiti di archiviazione della blockchain Bitcoin aumentano continuamente se non esegui il pruning, mentre i requisiti della CPU non lo fanno (o non lo fanno nella stessa misura). Uno storage da 320 GibiByte costerebbe 32 $ al mese, che combinato con un Linode da 4 GB è di 52 $ al mese, invece di 80 $, e cosa più importante, puoi continuare a farlo crescere. Non documentiamo completamente questa configurazione per due motivi (1) non suggeriamo la configurazione mainnet non potata, e quindi sospettiamo che sia una configurazione molto meno comune; e (2) non abbiamo testato come i volumi Linode si confrontano con i loro SSD intrinseci per prestazioni e utilizzo. Ma c'è una documentazione completa sulla pagina Block Storage. Dovresti configurare Linode, eseguire il suo stackscript, ma poi interromperlo per spostare eccessivamente lo storage blockchain su un volume appena commissionato prima di continuare. ### Esegui la configurazione finale -L'ultima cosa che devi fare è inserire una password di root. (Se hai dimenticato qualcosa, te lo diremo ora!) +Ora potresti voler cambiare il nome del tuo VPS Linode, che di default è `linodexxxxxxxx`. Ad esempio, potresti chiamarlo `bitcoin-signet-pruned` per distinguerlo dagli altri VPS del tuo account. -Fai clic su "Deploy" per inizializzare i dischi e preparare il tuo VPS. L'intera coda dovrebbe essere eseguita in meno di un minuto. Quando è terminata, dovresti vedere nella "Host Job Queue" i pulsanti verdi "Success" che indicano "Disk Create from StackScript - Setting password for root… done." e "Create Filesystem - 256MB Swap Image". +L'ultima cosa da fare è inserire la password di root. (Se hai dimenticato qualcosa, ti verrà detto ora!). A questo punto avrai anche la possibilità di aggiungere una chiave SSH per l'utente root. Anche in questo caso, ti consigliamo di farlo sia per motivi di sicurezza che di comodità. -Ora potresti voler cambiare il nome del tuo Linode VPS dal predefinito `linodexxxxxxxx`. Vai alla scheda Impostazioni e cambia l'etichetta in modo che sia più utile, come il nome host breve del tuo VPS. Ad esempio, potresti chiamarlo `bitcoin-testnet-pruned` per differenziarlo dagli altri VPS nel tuo account. +Linode offre attualmente alcune opzioni che sono cambiate nel tempo, ma che al momento includono: crittografia del disco, VPC, firewall e VLAN. Si tratta generalmente di funzionalità di sicurezza da considerare per un'implementazione reale, ma non necessarie per un ambiente di test. (Per un'implementazione reale, consigliamo almeno un firewall e la crittografia del disco, ma la decisione finale spetta a voi e al vostro team di sicurezza). + +Fai clic su "Deploy" per inizializzare i dischi e preparare il tuo VPS. L'intera procedura dovrebbe essere completata in meno di un minuto. Al termine, nella sezione "Host Job Queue" dovresti visualizzare dei pulsanti verdi con la scritta "Success" che indicano "Disk Create from StackScript - Setting password for root… done." e "Create Filesystem - 256MB Swap Image". ## Accedi al tuo VPS @@ -148,7 +130,7 @@ Se sei impaziente puoi andare avanti e digitare `sudo tail -f ~root/standup.log` ## Verifica la tua installazione -Saprai che stackscrpit è stato eseguito quando la `tail` di `standup.log` dice qualcosa del tipo: +Saprai che stackscript è stato eseguito quando la `tail` di `standup.log` dice qualcosa del tipo: ``` /root/StackScript - Bitcoin is setup as a service and will automatically start if your VPS reboots and so is Tor @@ -160,7 +142,9 @@ A quel punto, la tua directory home dovrebbe apparire così: ``` $ ls -bitcoin-0.20.0-x86_64-linux-gnu.tar.gz laanwj-releases.asc SHA256SUMS.asc +bitcoin-30.2-x86_64-linux-gnu.tar.gz wget-btc-output.txt +SHA256SUMS wget-btc-sha-asc-output.txt +SHA256SUMS.asc wget-btc-sha-output.txt ``` Questi sono i vari file che sono stati utilizzati per installare Bitcoin sul tuo VPS. _Nessuno_ di loro è necessario. Li abbiamo lasciati solo nel caso in cui volessi fare delle verifiche aggiuntive. Altrimenti, puoi eliminarli: @@ -174,20 +158,35 @@ Verifica la configurazione di Bitcoin Per garantire che la versione di Bitcoin scaricata sia valida, StackScript controlla sia la firma che il checksum SHA. Dovresti verificare che entrambi i test siano tornati corretti: ``` -$ sudo grep VERIFICATION ~root/standup.log +$ sudo grep VERIFICATION /standup.log ``` Se vedi qualcosa di simile a quanto segue, tutto dovrebbe andare bene: ``` -/root/StackScript - VERIFICATION SUCCESS / SIG: gpg: Good signature from "Wladimir J. van der Laan (Bitcoin Core binary release signing key) " [unknown] -/root/StackScript - VERIFICATION SUCCESS / SHA: 35ec10f87b6bc1e44fd9cd1157e5dfa4``` +/root/StackScript - SIG VERIFICATION SUCCESS: 8 GOOD SIGNATURES FOUND. +/root/StackScript - SHA VERIFICATION SUCCESS / SHA: bitcoin-30.2-x86_64-linux-gnu.tar.gz: OK ``` -However, if either of those two checks instead reads "VERIFICATION ERROR", then there's a problem. Since this is all scripted, it's possible that there's just been a minor change that has caused the script's checks not to work right. (This has happened a few times over the existence of the script that became Standup.) But, it's also possible that someone is trying to encourage you to run a fake copy of the Bitcoin daemon. So, _be very sure you know what happened before you make use of Bitcoin!_ +Tuttavia, se uno di quei due controlli invece dice "VERIFICATION ERROR", allora c'è un problema. +Il log contiene anche ulteriori informazioni sulle firme, nel caso in cui vogliate accertarvi di sapere chi ha firmato il rilascio di Bitcoin: + + +``` +$ sudo grep -i good /standup.log +/root/StackScript - SIG VERIFICATION SUCCESS: 8 GOOD SIGNATURES FOUND. +gpg: Good signature from ".0xB10C " [unknown] +gpg: Good signature from "Ava Chow " [unknown] +gpg: Good signature from "Stephan Oeste (it) " [unknown] +gpg: Good signature from "Michael Ford (bitcoin-otc) " [unknown] +gpg: Good signature from "Oliver Gugger " [unknown] +gpg: Good signature from "Hennadii Stepanov (hebasto) " [unknown] +gpg: Good signature from "Matthew Zipkin (GitHub Signing Key) " [unknown] +gpg: Good signature from "Sjors Provoost " [unknown] +``` -Tuttavia, se uno di quei due controlli invece dice "VERIFICATION ERROR", allora c'è un problema. Poiché tutto questo è scritto in uno script, è possibile che ci sia stata solo una piccola modifica che ha causato il malfunzionamento dei controlli dello script. (Questo è successo un paio di volte durante l'esistenza dello script che è diventato Standup.) Ma è anche possibile che qualcuno stia cercando di incoraggiarti a eseguire una copia falsa del Bitcoin daemon. Quindi, _assicurati di sapere cosa è successo prima di usare Bitcoin!_ +Poiché tutto questo è scritto in uno script, è possibile che ci sia stata solo una piccola modifica che ha causato il malfunzionamento dei controlli dello script. (Questo è successo un paio di volte durante l'esistenza dello script che è diventato Standup.) Ma è anche possibile che qualcuno stia cercando di incoraggiarti a eseguire una copia falsa del Bitcoin daemon. Quindi, _assicurati di sapere cosa è successo prima di usare Bitcoin!_ ### Leggi i log @@ -209,7 +208,7 @@ Se tutto sembra a posto, congratulazioni, hai un nodo Bitcoin funzionante usando ## Cosa abbiamo fatto -Sebbene l'immagine Debian 10 predefinita che stiamo usando per il tuo VPS sia stata modificata da Linode per essere relativamente sicura, il tuo nodo Bitcoin installato tramite Linode StackScript è impostato con un livello di sicurezza ancora più elevato. Potresti trovare questo limitante o non essere in grado di fare le cose che ti aspetti. Ecco alcune note a riguardo: +Sebbene l'immagine Debian 13 predefinita che stiamo usando per il tuo VPS sia stata modificata da Linode per essere relativamente sicura, il tuo nodo Bitcoin installato tramite Linode StackScript è impostato con un livello di sicurezza ancora più elevato. Potresti trovare questo limitante o non essere in grado di fare le cose che ti aspetti. Ecco alcune note a riguardo: ### Servizi protetti @@ -250,10 +249,10 @@ Ma aspetta, il tuo Bitcoin daemon sta probabilmente ancora scaricando blocchi. ` ``` $ bitcoin-cli getblockcount -1771352 +288191 ``` -Se è diverso ogni volta che digiti il comando, devi aspettare prima di lavorare con Bitcoin. Attualmente ci vogliono da 1 a 6 ore per una configurazione ridotta, a seconda della tua macchina. +Se è diverso ogni volta che digiti il comando, devi aspettare prima di lavorare con Bitcoin. Questa operazione può richiedere ore per la configurazione della mainnet, ma se si utilizza la configurazione suggerita con pruned signet, dovrebbe essere completata in circa 15 minuti. Ma una volta che si stabilizza su un numero, sei pronto per continuare! @@ -261,8 +260,6 @@ Tuttavia, potrebbe essere il momento di qualche altro caffè. Ma presto il tuo s - - ## Riepilogo: Impostazione manuale di un VPS Bitcoin-Core Creare un VPS Bitcoin-Core con gli script Standup ha reso l'intero processo rapido, semplice e (si spera) indolore. @@ -281,7 +278,11 @@ Hai alcune opzioni per cosa c'è dopo: **Pruned Mainnet.** Questo taglierà la blockchain che stai memorizzando fino agli ultimi 550 blocchi. Se non stai estraendo o eseguendo un altro servizio Bitcoin, questo dovrebbe essere più che sufficiente per la convalida. -**Testnet.** Questo ti dà accesso a una blockchain Bitcoin alternativa in cui i Bitcoin non hanno effettivamente valore. È pensato per la sperimentazione e il test. +**Signet.** Questa è la versione più recente di una rete di test, in cui i Bitcoin non hanno alcun valore effettivo, e ha ampiamente superato Testnet. È pensata per la sperimentazione e i test. Il suo grande vantaggio è che la produzione di blocchi è più affidabile di quella di Testnet, dove quest'ultima poteva bloccarsi per un certo periodo per poi produrre una serie di blocchi in rapida successione. + +**Pruned Signet.** Gli ultimi 550 blocchi della Signet. + +**Testnet.** La vecchia rete di test, ancora utile ad alcuni per la possibilità offerta ai miner di forzare la riorganizzazione dei blocchi (e probabilmente per altri scopi di test specifici). Attualmente è `testnet3`, ma prevediamo che verrà aggiornata a `testnet4` nel prossimo futuro (il che dovrebbe ridurre le attuali grandi dimensioni della blockchain). **Pruned Testnet.** Questi sono solo gli ultimi 550 blocchi di Testnet... perché anche la blockchain di Testnet è piuttosto grande ora. diff --git a/it/03_0_Comprendere_la_Configurazione_di_Bitcoin.md b/it/03_0_Comprendere_la_Configurazione_di_Bitcoin.md index 1b27b4da3..be16aca41 100644 --- a/it/03_0_Comprendere_la_Configurazione_di_Bitcoin.md +++ b/it/03_0_Comprendere_la_Configurazione_di_Bitcoin.md @@ -23,9 +23,9 @@ Gli obiettivi di supporto includono la capacità di: ## Sommario -* [Capitolo 3.1: Verificare la configurazione Bitcoin](03_1_Verificare_la_configurazione_Bitcoin.md) +* [Capitolo 3.1: Verificare la configurazione di Bitcoin](03_1_Verificare_la_configurazione_di_Bitcoin.md) * [Capitolo 3.2: Capire la configurazione di Bitcoin](03_2_Capire_la_configurazione_di_Bitcoin.md) -* [Capitolo 3.3: Configurare la wallet](03_3_Configurare_la_wallet.md) - * [Interludio: Utilizzare Variabili nella Linea di Comando](03_3_Intermezzo_Utilizzare_Variabili_nella_Linea_di_Comando.md) -* [Capitolo 3.4: Ricivere una Transazione](03_4_Ricivere_una_Transazione.md) +* [Capitolo 3.3: Configurare la Wallet](03_3_Configurare_la_Wallet.md) +* [Interludio: Utilizzare Variabili nella Linea di Comando](03_3_Intermezzo_Utilizzare_Variabili_nella_Linea_di_Comando.md) +* [Capitolo 3.4: Ricevere una Transazione](03_4_Ricevere_una_Transazione.md) * [Capitolo 3.5: Comprendere il Descriptor](03_5_Comprendere_il_Descriptor.md) diff --git a/it/03_1_Verificare_la_configurazione_Bitcoin.md b/it/03_1_Verificare_la_configurazione_di_Bitcoin.md similarity index 100% rename from it/03_1_Verificare_la_configurazione_Bitcoin.md rename to it/03_1_Verificare_la_configurazione_di_Bitcoin.md diff --git a/it/03_2_Capire_la_configurazione_di_Bitcoin.md b/it/03_2_Capire_la_configurazione_di_Bitcoin.md index 3ac1c9a13..635d3df52 100644 --- a/it/03_2_Capire_la_configurazione_di_Bitcoin.md +++ b/it/03_2_Capire_la_configurazione_di_Bitcoin.md @@ -11,7 +11,7 @@ La directory principale contiene solo il file di configurazione e la directory d $ ls ~/.bitcoin bitcoin.conf testnet3 ``` -Le guide di configurazione nel [Capitolo 2: Configurare Bitcoin-Core VPS](02_0_Configurare_Bitcoin-Core_VPS.md) presentano un file di configurazione standardizzato. [Capitolo 3.1: Verificare la configurazione Bitcoin](03_1_Verificare_la_configurazione_Bitcoin.md) ha suggerito come modificarlo per supportare configurazioni più avanzate. Se sei interessato a saperne di più sul file di configurazione, potresti consultare [Bitcoin Core Config Generator di Jameson Lopp](https://jlopp.github.io/bitcoin-core-config-generator/). +Le guide di configurazione nel [Capitolo 2: Configurare Bitcoin-Core VPS](02_0_Configurare_Bitcoin-Core_VPS.md) presentano un file di configurazione standardizzato. [Capitolo 3.1: Verificare la configurazione di Bitcoin](03_1_Verificare_la_configurazione_di_Bitcoin.md) ha suggerito come modificarlo per supportare configurazioni più avanzate. Se sei interessato a saperne di più sul file di configurazione, potresti consultare [Bitcoin Core Config Generator di Jameson Lopp](https://jlopp.github.io/bitcoin-core-config-generator/). Tornando alla directory ~/.bitcoin, scoprirai che la directory testnet3 contiene tutto il resto: ``` diff --git a/it/03_3_Configurare_la_Wallet.md b/it/03_3_Configurare_la_Wallet.md index eeb33f1bb..e94f1181b 100644 --- a/it/03_3_Configurare_la_Wallet.md +++ b/it/03_3_Configurare_la_Wallet.md @@ -79,7 +79,7 @@ Le transazioni Bitcoin classiche hanno creato indirizzi P2PKH che hanno aggiunto > :book: ***Che cos'è un indirizzo Legacy (P2PKH)?*** Questo è un indirizzo Legacy del tipo utilizzato dalla prima rete Bitcoin. Lo useremo negli esempi per le prossime sezioni. Si chiama indirizzo _Pay to PubKey Hash_ (o P2PKH) perché l'indirizzo è un hash a 160 bit di una chiave pubblica. L'utilizzo di un hash della tua chiave pubblica come indirizzo crea un processo in due fasi in cui è necessario rivelare sia la chiave privata che quella pubblica per spendere i fondi, aumenta di conseguenza la sicurezza futura. Questo tipo di indirizzo rimane importante per ricevere fondi da persone con software wallet non aggiornato. -Come descritto più dettagliatamente nel [Capitolo 4.6: Creare una Transazione Segwit](04_6_Creating_a_Segwit_Transaction.md), le guerre sulle dimensioni dei blocchi della fine degli anni 2010 hanno portato a un nuovo tipo di indirizzo: *SegWit*. Questo è il tipo di indirizzo preferito, oggi è completamente integrato in Bitcoin-Core, ma i dettagli li vedremo nel Capitolo 4.6. +Come descritto più dettagliatamente nel [Capitolo 4.6: Creare una Transazione Segwit](04_6_Creare_una_Transazione_Segwit.md), le guerre sulle dimensioni dei blocchi della fine degli anni 2010 hanno portato a un nuovo tipo di indirizzo: *SegWit*. Questo è il tipo di indirizzo preferito, oggi è completamente integrato in Bitcoin-Core, ma i dettagli li vedremo nel Capitolo 4.6. SegWit significa semplicemente "testimone separato" ed è un modo per separare le firme delle transazioni dal resto della transazione per ridurre le dimensioni e il costo della transazione. Alcuni indirizzi SegWit si insinueranno in alcuni dei nostri esempi precedenti al Capitolo 4.6 come indirizzi di devoluzione del resto, "change", che vedrai come indirizzi che iniziano con "tb". Questo va bene perché `bitcoin-cli` supporta interamente il loro utilizzo. diff --git a/it/04_0_Inviare_Transazioni_Bitcoin.md b/it/04_0_Inviare_Transazioni_Bitcoin.md index 5ee8b56cf..53cca1fcb 100644 --- a/it/04_0_Inviare_Transazioni_Bitcoin.md +++ b/it/04_0_Inviare_Transazioni_Bitcoin.md @@ -24,7 +24,7 @@ Gli obiettivi di supporto includono la capacità di: * [Sezione 4.2: Creare una Transazione Grezza](04_2_Creare_una_Transazione_Grezza.md) * [Intermezzo: Usare JQ](04_2_Intermezzo_Usare_JQ.md) * [Sezione 4.3: Creare una Transazione Grezza con Alias](04_3_Creare_una_Transazione_Grezza_con_Alias.md) - * [Sezione 4.4: Enviare Monete con Transazione Grezza](04_4_Enviare_Monete_con_Transazione_Grezza.md) + * [Sezione 4.4: Inviare Monete con Transazione Grezza](04_4_Inviare_Monete_con_Transazione_Grezza.md) * [Intermezzo: Usare Curl](04_4_Intermezzo_Usare_Curl.md) * [Sezione 4.5: Inviare Monete con Transazione Grezza Automatizzata](04_5_Inviare_Monete_con_Transazione_Grezza_Automatizzata.md) * [Sezione 4.6: Creare una Transazione Segwit](04_6_Creare_una_Transazione_Segwit.md) diff --git a/it/04_1_Inviare_Monete_Modo_Semplice.md b/it/04_1_Inviare_Monete_Modo_Semplice.md index 5f77a4d87..e011e465e 100644 --- a/it/04_1_Inviare_Monete_Modo_Semplice.md +++ b/it/04_1_Inviare_Monete_Modo_Semplice.md @@ -8,7 +8,7 @@ Prima di inviare denaro sulla rete Bitcoin, dovresti pensare a quali commissioni > :book: ***Che cos'è una commissione di transazione?*** _Non esiste un pranzo gratis_. I minatori incorporano le transazioni nei blocchi perché sono pagati per farlo. Non solo vengono pagati dalla rete per effettuare il blocco, ma vengono anche pagati dagli utenti per includere le loro transazioni. Se non paghi una commissione, la tua transazione potrebbe rimanere bloccata... per sempre (o, fino a quando non verrà salvata da alcuni dei trucchi nel [Capitolo 5](05_0_Controllare_Transazioni_Bitcoin.md). -Quando utilizzi metodi semplici e automatizzati per creare transazioni, come delineato qui e nel [Capitolo 4.5: Inviare Monete con Transazione Cruda Automatizzata](04_5_Inviare_Monete_con_Transazione_Cruda_Automatizzata.md), Bitcoin calcolerà le commissioni di transazione per te. Questo viene fatto utilizzando le commissioni variabili, in cui "bitcoind" osserva quanto tempo impiegano le transazioni per essere confermate e calcola automaticamente quanto spendere. +Quando utilizzi metodi semplici e automatizzati per creare transazioni, come delineato qui e nel [Capitolo 4.5: Inviare Monete con Transazione Grezza Automatizzata](04_5_Inviare_Monete_con_Transazione_Grezza_Automatizzata.md), Bitcoin calcolerà le commissioni di transazione per te. Questo viene fatto utilizzando le commissioni variabili, in cui "bitcoind" osserva quanto tempo impiegano le transazioni per essere confermate e calcola automaticamente quanto spendere. Puoi contribuire a controllarlo inserendo valori razionali nel tuo `~/.bitcoin/bitcoin.conf`. I seguenti valori a basso costo garantirebbero che ci fosse una commissione di transazione minima di 10.000 satoshi per kByte di dati nella transazione e richiederebbero che le commissioni variabili raggiungano un buon importo per portare la transazione da qualche parte nei successivi sei blocchi. ``` @@ -103,4 +103,4 @@ Per inviare monete nel modo più semplice, assicurati che le impostazioni predef ## Con cosa andiamo avanti? -Andiamo avanti col'invio di transazioni Bitcoin con [inviare Monete con Transazione Grezza](04_4_inviare_Monete_con_Transazione_Grezza.md). +Andiamo avanti col'invio di transazioni Bitcoin con [inviare Monete con Transazione Grezza](04_4_Inviare_Monete_con_Transazione_Grezza.md). diff --git a/it/05_0_Controllare_Transazioni_Bitcoin.md b/it/05_0_Controllare_Transazioni_Bitcoin.md index 593de6360..403b65bf6 100644 --- a/it/05_0_Controllare_Transazioni_Bitcoin.md +++ b/it/05_0_Controllare_Transazioni_Bitcoin.md @@ -20,4 +20,4 @@ Gli obiettivi di supporto includono la capacità di: * [Capitolo 5.1:Guardare le Transazioni Ferme](05_1_Guardare_le_Transazioni_Ferme.md) * [Capitolo 5.2: Rinviare le Transazioni con RBF](05_2_Rinviare_le_Transazioni_con_RBF.md) - * [Capitolo 5.3: Pagare una Transaccion con CPFP](05_3_Pagare_una_Transaccion_con_CPFP.md) + * [Capitolo 5.3: Pagare una Transazione con CPFP](05_3_Pagare_una_Transazione_con_CPFP.md) diff --git a/it/05_1_Guardare_le_Transazioni_Ferme.md b/it/05_1_Guardare_le_Transazioni_Ferme.md index 0f75f2103..c5a779eb1 100644 --- a/it/05_1_Guardare_le_Transazioni_Ferme.md +++ b/it/05_1_Guardare_le_Transazioni_Ferme.md @@ -49,7 +49,7 @@ Se la transazione rimane bloccata più a lungo del previsto, in genere puoi fare **3. Come mitente utilizza RBF.** Se sei il mittente della transazione e hai aderito a RBF (Replace-By-Fee), puo riprovare con una commissione più alta. Vedere [Capitolo 5.2: Rinviare le Transazioni con RBF](05_2_Rinviare_le_Transazioni_con_RBF.md). -**4. Come destinatario utilizza CPFP.** In alternativa, se sei il destinatario della transazione, puoi utilizzare CPFP (Child-pays-for-parent) per utilizzare la transazione non confermata come input per una nuova transazione. Vedi [Capitolo 5.3: 05_3 Pagare una Transaccion con CPFP](05_3_Pagare_una_Transaccion_con_CPFP.md). +**4. Come destinatario utilizza CPFP.** In alternativa, se sei il destinatario della transazione, puoi utilizzare CPFP (Child-pays-for-parent) per utilizzare la transazione non confermata come input per una nuova transazione. Vedi [Capitolo 5.3: 05_3 Pagare una Transazione con CPFP](05_3_Pagare_una_Transazione_con_CPFP.md). ## Riepilogo: Guardare le transazioni ferme diff --git a/it/05_2_Rinviare_le_Transazioni_con_RBF.md b/it/05_2_Rinviare_le_Transazioni_con_RBF.md index 61a6458cc..d5d6cf224 100644 --- a/it/05_2_Rinviare_le_Transazioni_con_RBF.md +++ b/it/05_2_Rinviare_le_Transazioni_con_RBF.md @@ -218,4 +218,4 @@ Se una transazione è ferma e non vuoi aspettare che scada del tutto, se hai ade ## Cosa c'è dopo? -Continua con "Controllo delle transazioni Bitcoin" nel [Capitolo 5.3: Pagare una Transaccion con CPFP](05_3_Pagare_una_Transaccion_con_CPFP.md). +Continua con "Controllo delle transazioni Bitcoin" nel [Capitolo 5.3: Pagare una Transazione con CPFP](05_3_Pagare_una_Transazione_con_CPFP.md). diff --git a/it/05_3_Pagare_una_Transaccion_con_CPFP.md b/it/05_3_Pagare_una_Transazione_con_CPFP.md similarity index 100% rename from it/05_3_Pagare_una_Transaccion_con_CPFP.md rename to it/05_3_Pagare_una_Transazione_con_CPFP.md diff --git a/it/06_1_Inviare_una_Transazione_a_un_Indirizzo_Multifirma.md b/it/06_1_Inviare_una_Transazione_a_un_Indirizzo_Multifirma.md index 6582b2c72..0f60f3a84 100644 --- a/it/06_1_Inviare_una_Transazione_a_un_Indirizzo_Multifirma.md +++ b/it/06_1_Inviare_una_Transazione_a_un_Indirizzo_Multifirma.md @@ -97,7 +97,8 @@ L'_indirizzo_ è ciò che darai alle persone che vogliono inviare fondi. Noterai > :link: **TESTNET vs MAINNET:** Su testnet, il prefisso per gli indirizzi P2SH è "2", mentre su mainnet è "3". -Il _redeemScript_ è ciò di cui hai bisogno per riscattare i fondi (insieme alle chiavi private per "m" degli "n" indirizzi). Questo script è un'altra caratteristica speciale degli indirizzi P2SH e verrà spiegato completamente nel [Capitolo 10.3 Eseguire un Script Bitcoin con P2SH](10_3_Eseguire_un_Script_Bitcoin_con_P2SH.md). Per ora, tieni presente che sono necessari alcuni dati per ottenere i tuoi soldi. +Il _redeemScript_ è ciò di cui hai bisogno per riscattare i fondi (insieme alle chiavi private per "m" degli "n" indirizzi). Questo script è un'altra caratteristica speciale degli indirizzi P2SH e verrà spiegato completamente nel [Capitolo 10.3 Eseguire uno Script Bitcoin con P2SH](10_3_Eseguire_uno_Script_Bitcoin_con_P2SH.md). Per ora, tieni presente che sono +necessari alcuni dati per ottenere i tuoi soldi. Il _descrittore_ è la descrizione standardizzata di un indirizzo che abbiamo incontrato nel [Capitolo 3.5 Comprendere il Descriptor](03_5_Comprendere_il_Descriptor.md). Fornisce un modo per importare nuovamente questo indirizzo sull'altra macchina, utilizzando l'RPC "importmulti". diff --git a/it/07_2_Usare_una_Transazione_Bitcoin_Parzialmente_Firmata.md b/it/07_2_Usare_una_Transazione_Bitcoin_Parzialmente_Firmata.md index af1c98dde..d2668c636 100644 --- a/it/07_2_Usare_una_Transazione_Bitcoin_Parzialmente_Firmata.md +++ b/it/07_2_Usare_una_Transazione_Bitcoin_Parzialmente_Firmata.md @@ -591,7 +591,7 @@ Il modo migliore per gestire un CoinJoin è inviare il PSBT di base a tutte le p ## Riepilogo: utilizzo di una transazione Bitcoin parzialmente firmata -Ora hai visto il processo PSBT che hai imparato in [§7.1](07_1_Creating_a_Partially_Signed_Bitcoin_Transaction.md) in uso in tre esempi di vita reale: creazione di un multi-sig, pooling di fondi e CoinJoining. Tutto ciò era teoricamente possibile nel Bitcoin classico facendo firmare più persone a transazioni attentamente costruite, ma i PSBT lo rendono standardizzato e semplice. +Ora hai visto il processo PSBT che hai imparato in [§7.1](07_1_Creare_una_Transazione_Bitcoin_Parzialmente_Firmata.md) in uso in tre esempi di vita reale: creazione di un multi-sig, pooling di fondi e CoinJoining. Tutto ciò era teoricamente possibile nel Bitcoin classico facendo firmare più persone a transazioni attentamente costruite, ma i PSBT lo rendono standardizzato e semplice. > :fire: ***Qual è il potere di un PSBT?*** Un PSBT consente la creazione di transazioni trustless tra più parti e più macchine. Se più di una parte avesse bisogno di finanziare una transazione, se più di una parte avesse bisogno di firmare una transazione, o se una transazione dovesse essere creata su una macchina e firmata su un’altra, allora un PSBT rende tutto semplice senza dipendere dal meccanismi di firma parziale non standardizzati che esistevano prima del PSBT. diff --git a/it/08_1_Inviare_una_Transazione_con_Blocco_temporale.md b/it/08_1_Inviare_una_Transazione_con_Blocco_temporale.md index 61a12303e..5188ae70c 100644 --- a/it/08_1_Inviare_una_Transazione_con_Blocco_temporale.md +++ b/it/08_1_Inviare_una_Transazione_con_Blocco_temporale.md @@ -12,7 +12,7 @@ Quando una transazione locktime è in attesa di entrare in un blocco, può esser > :book: **_Cos'è nLockTime?_** È la stessa cosa di locktime. Più specificamente, è ciò che viene chiamato locktime interno al codice sorgente di Bitcoin Core. -> :book: **_Che cos'è Timelock?_** Locktime è solo un modo per trattenere le transazioni Bitcoin fino a un certo punto nel futuro; collettivamente questi metodi sono chiamati timelock. Locktime è il metodo di blocco temporale più semplice. Blocca un'intera transazione con un tempo assoluto ed è disponibile tramite `bitcoin-cli` (motivo per cui è l'unico blocco temporale trattato in questa sezione). Un metodo parallelo, che blocca una transazione con un tempo relativo, è definito nel [BIP 68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki) e trattato nel [Capitolo 11.3: Utilizzo di CSV negli script](11_3_Using_CSV_in_Scripts.md). +> :book: **_Che cos'è Timelock?_** Locktime è solo un modo per trattenere le transazioni Bitcoin fino a un certo punto nel futuro; collettivamente questi metodi sono chiamati timelock. Locktime è il metodo di blocco temporale più semplice. Blocca un'intera transazione con un tempo assoluto ed è disponibile tramite `bitcoin-cli` (motivo per cui è l'unico blocco temporale trattato in questa sezione). Un metodo parallelo, che blocca una transazione con un tempo relativo, è definito nel [BIP 68](https://github.com/bitcoin/bips/blob/master/bip-0068.mediawiki) e trattato nel [Capitolo 11.3: Utilizzo di CSV negli script](11_3_Usare_CSV_negli_Scripts.md). > Bitcoin Script potenzia ulteriormente entrambi i tipi di blocchi temporali, consentendo il blocco di singoli output anziché di intere transazioni. I timelock assoluti (come Locktime) sono collegati al codice operativo dello script OP_CHECKLOCKTIMEVERIFY, che è definito in [BIP 65](https://github.com/bitcoin/bips/blob/master/bip-0065.mediawiki) e trattato in [ §11.2: Using CLTV in Scripts](11_2_Usare_CLTV_negli_Scripts.md), mentre i timelock relativi (come Timelock) sono collegati al codice operativo dello script `OP_CHECKSEQUENCEVERIFY`, che è definito nel [BIP 112](https://github.com/bitcoin/bips/blob/master/bip-0112.mediawiki) e trattato anche nel [Capitolo11.3](11_3_Usare_CSV_negli_Scripts.md). diff --git a/it/09_3_Provare_uno_Script_Bitcoin.md b/it/09_3_Provare_uno_Script_Bitcoin.md index d2408abaf..1cff64d4c 100644 --- a/it/09_3_Provare_uno_Script_Bitcoin.md +++ b/it/09_3_Provare_uno_Script_Bitcoin.md @@ -200,7 +200,7 @@ Anche con un ottimo strumento come `btcdeb` o risorse transitorie come i vari te Quindi l'unico modo per testare _veramente_ gli script Bitcoin è provarli su Testnet. -E come lo fai? Si dà il caso che questo sia l'argomento del [Capitolo 10](110_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md), che esamina l'introduzione di questi script astratti nel mondo reale di Bitcoin incorporandoli nelle transazioni P2SH. (Ma anche in questo caso, probabilmente avrai bisogno di un'API per inviare la tua transazione P2SH sulla rete Bitcoin, quindi i test completi saranno ancora possibili in futuro.) +E come lo fai? Si dà il caso che questo sia l'argomento del [Capitolo 10](10_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md), che esamina l'introduzione di questi script astratti nel mondo reale di Bitcoin incorporandoli nelle transazioni P2SH. (Ma anche in questo caso, probabilmente avrai bisogno di un'API per inviare la tua transazione P2SH sulla rete Bitcoin, quindi i test completi saranno ancora possibili in futuro.) _Quali_ siano gli altri metodi di test che hai utilizzato, testare uno script su Testnet dovrebbe essere il tuo test finale _prima_ di inserire lo script su Mainnet. Non fidarti che il tuo codice sia corretto; non limitarti a guardarlo. Non fidarti nemmeno dei simulatori o debugger che hai utilizzato. Farlo è un altro ottimo modo per perdere fondi su Bitcoin. diff --git a/it/09_4_Programmare_una_P2PKH.md b/it/09_4_Programmare_una_P2PKH.md index d7be02771..efd8567fd 100644 --- a/it/09_4_Programmare_una_P2PKH.md +++ b/it/09_4_Programmare_una_P2PKH.md @@ -385,4 +385,4 @@ L'invio a un indirizzo P2PKH era relativamente semplice quando utilizzavi solo ` ## Qual è il prossimo argomento? -Continua l' "Introduzione agli script Bitcoin" con [Capitolo 9.5: Scripting a P2WPKH](09_5_Scripting_a_P2WPKH.md). +Continua l' "Introduzione agli script Bitcoin" con [Capitolo 9.5: Script di un P2WPKH](09_5_Programmare_una_P2WPKH.md). diff --git a/it/10_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md b/it/10_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md index 8a93d3fe7..fc289b13f 100644 --- a/it/10_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md +++ b/it/10_0_Inserire_Scripts_di_Bitcoin_in_Transazioni_P2SH.md @@ -20,7 +20,7 @@ Gli obiettivi di supporto includono la capacità di: * [Capitolo 10.1: Comprendere la Base di P2SH](10_1_Comprendere_la_Base_di_P2SH.md) * [Capitolo 10.2: Construire la Struttura di P2SH](10_2_Construire_la_Struttura_di_P2SH.md) -* [Capitolo 10.3: Eseguire un Script Bitcoin con P2SH](10_3_Eseguire_un_Script_Bitcoin_con_P2SH.md) +* [Capitolo 10.3: Eseguire un Script Bitcoin con P2SH](10_3_Eseguire_uno_Script_Bitcoin_con_P2SH.md) * [Capitolo 10.4: Programmare una Multifirma](10_4_Programmare_una_Multifirma.md) * [Capitolo 10.5: Programmare uno Script Segwit](10_5_Programmare_uno_Script_Segwit.md) * [Capitolo 10.6: Spendere una Transazione P2SH](10_6_Spendere_una_Transazione_P2SH.md) diff --git a/it/10_2_Construire_la_Struttura_di_P2SH.md b/it/10_2_Construire_la_Struttura_di_P2SH.md index 856d35dbb..a2c3359e3 100644 --- a/it/10_2_Construire_la_Struttura_di_P2SH.md +++ b/it/10_2_Construire_la_Struttura_di_P2SH.md @@ -121,7 +121,7 @@ Ecco cosa significano le singole parti: * 0x52 = OP_2 * 0xae = OP_CHECKMULTISIG -In altre parole, quel `redeemScript` era una traduzione di `2 02da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d191 02bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa3 2 OP_CHECKMULTISIG`. Torneremo su questo script nel [Capitolo 10.4:Scripting a Multisig](10_4_Scripting_a_Multisig.md) quando dettaglieremo esattamente come funzionano i multisig all'interno del paradigma P2SH. +In altre parole, quel `redeemScript` era una traduzione di `2 02da2f10746e9778dd57bd0276a4f84101c4e0a711f9cfd9f09cde55acbdd2d191 02bfde48be4aa8f4bf76c570e98a8d287f9be5638412ab38dede8e78df82f33fa3 2 OP_CHECKMULTISIG`. Torneremo su questo script nel [Capitolo 10.4:Programmare una Multifirma](10_4_Programmare_una_Multifirma.md) quando dettaglieremo esattamente come funzionano i multisig all'interno del paradigma P2SH. Se desideri un aiuto meccanico con questo tipo di traduzione in futuro, puoi usare `bitcoin-cli decodescript`: @@ -190,5 +190,3 @@ Creare effettivamente lo script di blocco P2SH ti porta più a fondo nel cuore d ## Cosa c'è Dopo? Continua "Incorporare Bitcoin Scripts" con [Capitolo 10.3: Eseguire uno Script Bitcoin con P2SH](10_3_Eseguire_uno_Script_Bitcoin_con_P2SH.md). - - diff --git a/it/11_2_Usare_CLTV_negli_Scripts.md b/it/11_2_Usare_CLTV_negli_Scripts.md index d06c0d6ee..4c494a436 100644 --- a/it/11_2_Usare_CLTV_negli_Scripts.md +++ b/it/11_2_Usare_CLTV_negli_Scripts.md @@ -8,7 +8,7 @@ Prima di approfondire CLTV, dovremmo prima ricordare come funziona `nLockTime`. -Come dettagliato in [§8.1: Invio di una Transazione con un Locktime](08_1_Sending_a_Transaction_with_a_Locktime.md), il locktime è abilitato impostando due variabili, `nLockTime` e `nSequence`. Il `nSequence` deve essere impostato a meno di 0xffffffff (di solito: 0xffffffff-1), poi il `nLockTime` è interpretato come segue: +Come dettagliato in [§8.1: Invio di una Transazione con un Locktime](08_1_Inviare_una_Transazione_con_Blocco_temporale.md), il locktime è abilitato impostando due variabili, `nLockTime` e `nSequence`. Il `nSequence` deve essere impostato a meno di 0xffffffff (di solito: 0xffffffff-1), poi il `nLockTime` è interpretato come segue: * Se il `nLockTime` è inferiore a 500 milioni, è interpretato come altezza di blocco. * Se il `nLockTime` è 500 milioni o più, è interpretato come un timestamp UNIX. @@ -81,7 +81,7 @@ Il seguente semplice script di blocco potrebbe essere usato per trasformare un o ### Codificare uno Script CLTV -Ovviamente, come per qualsiasi script Bitcoin complesso, questo script CLTV sarebbe effettivamente codificato in uno script P2SH, come spiegato in [§10.1: Comprendere le Basi di P2SH](10_1_Understanding_the_Foundation_of_P2SH.md) e [§10.2: Costruire la Struttura di P2SH](10_2_Building_the_Structure_of_P2SH.md). +Ovviamente, come per qualsiasi script Bitcoin complesso, questo script CLTV sarebbe effettivamente codificato in uno script P2SH, come spiegato in [§10.1: Comprendere le Basi di P2SH](10_1_Comprendere_la_Base_di_P2SH.md) e [§10.2: Costruire la Struttura di P2SH](10_2_Construire_la_Struttura_di_P2SH.md). Supponendo che `` fosse l'intero "1546288031" (hex little-endian: 0x9f7b2a5c) e `` fosse "371c20fb2e9899338ce5e99908e64fd30b789313", questo `redeemScript` sarebbe costruito come: diff --git a/it/13_1_Scrivere_Scripts_Enigmatici.md b/it/13_1_Scrivere_Scripts_Puzzle.md similarity index 98% rename from it/13_1_Scrivere_Scripts_Enigmatici.md rename to it/13_1_Scrivere_Scripts_Puzzle.md index 19451c293..9fd2635d3 100644 --- a/it/13_1_Scrivere_Scripts_Enigmatici.md +++ b/it/13_1_Scrivere_Scripts_Puzzle.md @@ -4,7 +4,7 @@ Gli Script Bitcoin _non_ devono necessariamente dipendere dalla conoscenza di un ## Scrivere Script di Algebra Semplici -Il nostro primo vero script, dal [Capitolo 9.2: Eseguire uno Script di Bitcoin](009_2_Eseguire_uno_Script_di_Bitcoin.md), era un enigma algebrico. Quello script Bitcoin, `OP_ADD 99 OP_EQUAL`, potrebbe essere descritto alternativamente come `x + y = 99`. +Il nostro primo vero script, dal [Capitolo 9.2: Eseguire uno Script di Bitcoin](09_2_Eseguire_uno_Script_di_Bitcoin.md), era un enigma algebrico. Quello script Bitcoin, `OP_ADD 99 OP_EQUAL`, potrebbe essere descritto alternativamente come `x + y = 99`. Questo tipo di script non ha molta applicabilità nel mondo reale, poiché è troppo facile rivendicare i fondi. Tuttavia, un concorso di risoluzione di enigmi che distribuisce piccole quantità di Bitcoin potrebbe proporlo come un intrattenimento divertente. @@ -510,4 +510,4 @@ Gli script enigmatici sono una grande introduzione a script Bitcoin più realist ## Cosa c'è dopo? -Continua "Progettare Veri Script Bitcoin" con [Capitolo 13.2: Scrivere Scripts Multifirma Complessi](13_2_Scrivere_Scripts_Multifirma_Complessi.md). +Continua "Progettare Veri Script Bitcoin" con [Capitolo 13.2: Scrivere Scripts Multifirma Complessi](13_2_Scrivere_Scripts_Multifirma_Complessi.md). diff --git a/it/16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md b/it/16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md index 753483cfb..f6a663251 100644 --- a/it/16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md +++ b/it/16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md @@ -2,7 +2,7 @@ > :information_source: **NOTA:** Questa sezione è stata recentemente aggiunta al corso ed è una bozza iniziale che potrebbe essere ancora in attesa di revisione. Lettore avvisato. -Hai già visto un modo alternativo per accedere alle porte RPC di Bitcoind: `curl`, che è stato trattato in un [Interludio del Capitolo 4](04_4__Interlude_Using_Curl.md). Interagire con `bitcoind` tramite una libreria RPC in C non è diverso da questo, hai solo bisogno di alcune buone librerie per aiutarti. Questa sezione introduce un pacchetto chiamato `libbitcoinrpc`, che ti permette di accedere alla porta JSON-RPC di `bitcoind`. Utilizza la libreria `curl` per accedere ai dati e la libreria `jansson` per codificare e decodificare il JSON. +Hai già visto un modo alternativo per accedere alle porte RPC di Bitcoind: `curl`, che è stato trattato in un [Interludio del Capitolo 4](04_4_Interlude_Using_Curl.md). Interagire con `bitcoind` tramite una libreria RPC in C non è diverso da questo, hai solo bisogno di alcune buone librerie per aiutarti. Questa sezione introduce un pacchetto chiamato `libbitcoinrpc`, che ti permette di accedere alla porta JSON-RPC di `bitcoind`. Utilizza la libreria `curl` per accedere ai dati e la libreria `jansson` per codificare e decodificare il JSON. ## Configurare libbitcoinrpc @@ -117,7 +117,7 @@ Innanzitutto, inizializza la libreria: ``` bitcoinrpc_global_init(); ``` -Poi connettiti al tuo `bitcoind` con `bitcoinrpc_cl_init_params`. I quattro argomenti per `bitcoinrpc_cl_init_params` sono nome utente, password, indirizzo IP e porta. Dovresti già conoscere tutte queste informazioni dal tuo lavoro con [Curl](04_4__Interlude_Using_Curl.md). Come ricorderai, l'indirizzo IP 127.0.0.1 e la porta 18332 dovrebbero essere corretti per la configurazione standard del testnet descritta in questi documenti, mentre puoi estrarre l'utente e la password da `~/.bitcoin/bitcoin.conf`. +Poi connettiti al tuo `bitcoind` con `bitcoinrpc_cl_init_params`. I quattro argomenti per `bitcoinrpc_cl_init_params` sono nome utente, password, indirizzo IP e porta. Dovresti già conoscere tutte queste informazioni dal tuo lavoro con [Curl](04_4_Intermezzo_Usare_Curl.md). Come ricorderai, l'indirizzo IP 127.0.0.1 e la porta 18332 dovrebbero essere corretti per la configurazione standard del testnet descritta in questi documenti, mentre puoi estrarre l'utente e la password da `~/.bitcoin/bitcoin.conf`. ``` $ cat bitcoin.conf server=1 diff --git a/it/17_5_Usare_Scripts_in_Libwally.md b/it/17_5_Usare_Scripts_in_Libwally.md index 372341533..6b0c184d2 100644 --- a/it/17_5_Usare_Scripts_in_Libwally.md +++ b/it/17_5_Usare_Scripts_in_Libwally.md @@ -6,7 +6,7 @@ Molto tempo fa, nella Parte 3, mentre introducevamo gli Script, abbiamo detto ch ## Crea lo Script -Creare lo script è la _cosa più facile_ da fare in Libwally. Prendi il seguente esempio, un semplice [Puzzle Script](/13_1_Writing_Puzzle_Scripts.md) al quale siamo tornati di tanto in tanto: +Creare lo script è la _cosa più facile_ da fare in Libwally. Prendi il seguente esempio, un semplice [Puzzle Script](13_1_Scrivere_Scripts_Puzzle.md) al quale siamo tornati di tanto in tanto: ``` OP_ADD 99 OP_EQUAL diff --git a/it/17_7_Integrare_Libwally_e_Bitcoin-CLI.md b/it/17_7_Integrare_Libwally_e_Bitcoin-CLI.md index 98f189d7a..5dd88412d 100644 --- a/it/17_7_Integrare_Libwally_e_Bitcoin-CLI.md +++ b/it/17_7_Integrare_Libwally_e_Bitcoin-CLI.md @@ -184,7 +184,7 @@ Purtroppo, non tutte le interazioni tra Libwally e `bitcoin-cli` sono così flui ## Importare Chiavi Private -Fortunatamente, puoi fare quasi la stessa cosa importando una chiave privata generata in Libwally. Dai un'occhiata a [genhd-for-import.c](src/17_7_genhd_for_import.c), una versione semplificata del programma `genhd` del [Capitolo 17.3](17_3_Usare_BIP32_in_Libwally.md) che utilizza anche la libreria `jansson` nel [Capitolo 16.1](116_1_Accedere_a_Bitcoind_con_Librerie_RPC.md) per un'uscita regolarizzata. +Fortunatamente, puoi fare quasi la stessa cosa importando una chiave privata generata in Libwally. Dai un'occhiata a [genhd-for-import.c](src/17_7_genhd_for_import.c), una versione semplificata del programma `genhd` del [Capitolo 17.3](17_3_Usare_BIP32_in_Libwally.md) che utilizza anche la libreria `jansson` nel [Capitolo 16.1](16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md) per un'uscita regolarizzata. Il codice aggiornato contiene anche una modifica importante: richiede un'impronta (fingerprint) da Libwally in modo da poter creare correttamente un percorso di derivazione: @@ -199,7 +199,7 @@ Il codice aggiornato contiene anche una modifica importante: richiede un'impront > :warning: **ATTENZIONE:** Ricorda che l'impronta nel percorso di derivazione è arbitraria. Poiché Libwally ne fornisce una, la stiamo usando, ma se non ne avessi una, potresti aggiungere un codice esadecimale arbitrario di 4 byte come impronta al tuo percorso di derivazione. -Assicurati di compilare il nuovo codice con la libreria `jansson`, dopo averla installata (se necessario) come indicato nel [Capitolo 16.1](116_1_Accedere_a_Bitcoind_con_Librerie_RPC.md). +Assicurati di compilare il nuovo codice con la libreria `jansson`, dopo averla installata (se necessario) come indicato nel [Capitolo 16.1](16_1_Accedere_a_Bitcoind_con_Librerie_RPC.md). ``` $ cc genhd-for-import.c -lwallycore -lsodium -ljansson -o genhd-for-import diff --git a/it/18_4_Accedere_a_Bitcoind_con_Python.md b/it/18_4_Accedere_a_Bitcoind_con_Python.md index 4ac6b9d20..b49b80cba 100644 --- a/it/18_4_Accedere_a_Bitcoind_con_Python.md +++ b/it/18_4_Accedere_a_Bitcoind_con_Python.md @@ -13,7 +13,7 @@ Puoi verificarlo eseguendo: Se restituisce un numero di versione (ad es., `3.7.3` o `3.8.3`) allora hai python3 installato. -Tuttavia, se in qualche modo non hai Python installato, dovrai compilarlo da sorgente come segue. Consulta la variante ["Compilare Python da Sorgente"](17_4_Accessing_Bitcoind_with_Python.md#variant-build-python-from-source) prima di continuare. +Tuttavia, se in qualche modo non hai Python installato, dovrai compilarlo da sorgente come segue. Consulta la variante ["Compilare Python da Sorgente"](18_4_Accedere_a_Bitcoind_con_Python.md#variante-compilare-python-da-sorgente) prima di continuare. ### Configurare BitcoinRPC @@ -482,7 +482,7 @@ Scopri di più su "Parlare con Bitcoin in Altri Linguaggi" in [18.5: Accesso a B ## Variante: Compilare Python da Sorgente -Se hai bisogno di installare Python 3 da sorgente, segui queste istruzioni, poi continua con ["Creare un Progetto BitcoinRPC"](18_4_Accessing_Bitcoind_with_Python.md#create-a-bitcoinrpc-project). +Se hai bisogno di installare Python 3 da sorgente, segui queste istruzioni, poi continua con ["Creare un Progetto BitcoinRPC"](18_4_Accessing_Bitcoind_with_Python.md#creare-un-progetto-bitcoinrpc). ### 1. Installare le Dipendenze diff --git a/it/19_2_Comprendere_la_Configurazione_Lightning.md b/it/19_2_Comprendere_la_Configurazione_Lightning.md index 4d7359137..7d8a16864 100644 --- a/it/19_2_Comprendere_la_Configurazione_Lightning.md +++ b/it/19_2_Comprendere_la_Configurazione_Lightning.md @@ -347,6 +347,6 @@ La directory `~/.lightning` contiene tutti i tuoi file, mentre `lightning-cli he ## Cosa Fare Dopo? -Avrai bisogno di un secondo nodo Linode per testare il pagamento effettivo delle fatture. Se hai bisogno di supporto per configurarlo, leggi [Interludio: Intermezzo Accedere ad un Secondo Nodo Lightning](19_2_Intermezzo_Accedere_ad_un_Secondo_Nodo_Lightning.mdd). +Avrai bisogno di un secondo nodo Linode per testare il pagamento effettivo delle fatture. Se hai bisogno di supporto per configurarlo, leggi [Interludio: Intermezzo Accedere ad un Secondo Nodo Lightning](19_2_Intermezzo_Accedere_ad_un_Secondo_Nodo_Lightning.md). Altrimenti, continua col argomento "Comprendere il Tuo Setup Lightning" nel [Capitolo 19.3: Creare un Canale in Lightning](19_3_Creare_un_Canale_in_Lightning.md). diff --git a/it/A1_0_Comprendere_Bitcoin_Standup.md b/it/A1_0_Comprendere_Bitcoin_Standup.md index c891067ca..3880c5137 100644 --- a/it/A1_0_Comprendere_Bitcoin_Standup.md +++ b/it/A1_0_Comprendere_Bitcoin_Standup.md @@ -12,7 +12,9 @@ Il fuso orario del tuo host è memorizzato in `/etc/timezone`, poi un file appro ## Passo 3: Aggiornamento di Debian -Il gestore di pacchetti `apt-get` viene utilizzato per aggiornare la tua macchina e per installare `gnupg`, il generatore di numeri casuali `haveged` e il firewall non complicato `ufw`. +Il gestore di pacchetti `apt-get` viene utilizzato per aggiornare la tua macchina e per installare `gnupg`, `git`, i generatori di numeri casuali `haveged` e `xxd` e il firewall non complicato `ufw`. + +I comandi `apt-get` vengono eseguiti con l'opzione `-y`, che dovrebbe forzare la risposta "sì" a tutte le domande e consentire l'esecuzione dello script senza interazione (ad esempio, come StackScript). Questo non ha funzionato con l'aggiornamento a Debian 13, poiché alcune domande rimanevano senza risposta e lo script si bloccava, quindi sono state aggiunte le opzioni `-o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold"` per dire: "Facciamo sul serio, niente domande!" La tua macchina è configurata per rimanere automaticamente aggiornata con `echo "unattended-upgrades unattended-upgrades/enable_auto_updates boolean true" | debconf-set-selections`. @@ -20,7 +22,7 @@ La tua macchina è configurata per rimanere automaticamente aggiornata con `echo Viene creato un utente `standup`, che sarà utilizzato per le tue applicazioni Bitcoin. Ha anche permessi `sudo`, permettendoti di eseguire azioni privilegiate con questo account. -Se hai fornito una chiave SSH, ti permetterà di accedere a questo account (altrimenti, devi usare la password creata durante la configurazione). +Se hai fornito una chiave Standup SSH, ti permetterà di accedere a questo account (altrimenti, devi usare la password creata durante la configurazione). Se hai fornito un indirizzo IP, l'accesso `ssh` sarà limitato a tale indirizzo, per `/etc/hosts.allow`. @@ -49,4 +51,3 @@ Bitcoin Standup utilizza script per cercare di eguagliare gran parte della funzi Se eri nel processo di creazione di un nodo Bitcoin per l'uso in questo corso, dovresti tornare al[Capitolo 2.1: Configurare Bitcoin Core VPS con StackScript](02_1_Configurare_Bitcoin-Core_VPS_con_StackScript.md). Se stai leggendo le appendici, continua con [Appendice A2: Compilare Bitcoin dal Codice Fonte](A2_0_Compilare_Bitcoin_dal_Codice_Fonte.md). - diff --git a/pt/01_0_Introduction.md b/pt/01_0_Introduction.md index 195418e31..f3bf9f8a8 100644 --- a/pt/01_0_Introduction.md +++ b/pt/01_0_Introduction.md @@ -1,16 +1,16 @@ -# Capítulo 1: Introdução à Aprendizagem do Bitcoin Core (& Lightning) pela Linha de Comando +# Capítulo 1: Introdução à Aprendizagem do Bitcoin Core (& Lightning) pela Linha de Comando ## Introdução Os modos como fazemos pagamentos por bens e serviços têm mudado drasticamente nas últimas décadas. Antigamente todas as transações eram realizadas utilizando dinheiro ou cheques, e atualmente os diversos métodos de pagamento eletrônico são à regra. Porém, a maioria dos pagamentos eletrônicos ainda ocorre utilizando sistemas centralizados, onde empresas de cartão de crédito, bancos ou até instituições financeiras baseadas apenas na Internet, como o PayPal, mantêm listas de transações longas e correlacionadas individualmente, tendo o poder de censurar as transações que não gostarem. -Esses riscos de centralização foram alguns dos catalisadores primordiais para a criação de criptomoedas, sendo a primeira e mais bem sucedida, o Bitcoin. O Bitcoin oferece pseudonímia; torna difícil correlacionar as transações; e torna a censura por entidades individuais, algo próximo do impossível. Essas vantagens fizeram dele uma das moedas mais rápidas do mundo. Esse crescimento, por sua vez, despertou o interesse dos empresários e desenvolvedores, ansiosos para criar novos serviços para a comunidade do Bitcoin. +Esses riscos de centralização foram alguns dos principais catalisadores por trás da criação de criptomoedas, a primeira e mais bem-sucedida das quais é o Bitcoin. Bitcoin oferece pseudônimo; dificulta a correlação das transações; e torna a censura por entidades individuais praticamente impossível. Essas vantagens a tornaram uma das moedas de crescimento mais rápido do mundo. Esse crescimento, por sua vez, tornou o Bitcoin uma preocupação contínua entre empreendedores e desenvolvedores, ansiosos para criar novos serviços para a comunidade Bitcoin. -Se você é um desses empreendedores ou desenvolvedores, então este curso é para você, porque ele tem tudo o que necessita para aprender a programar no Bitcoin. É um curso introdutório que explica todas as nuances e características do Bitcoin e de tudo o que vem com ele. O curso também oferece algumas coisas mais específicas, como aulas de como utilizar _diretamente_ o Bitcoin Core com o servidor C-Lightning usando suas interfaces RPC. +Se você é um desses empreendedores ou desenvolvedores, então este curso é para você, porque é tudo sobre aprender a programar Bitcoin. É um curso introdutório que explica todas as nuances e características do Bitcoin à medida que avança. Ele também adota uma abordagem muito específica, oferecendo lições sobre como trabalhar _diretamente_ com o Bitcoin Core e com o servidor c-lightning usando suas interfaces RPC. -Por que não utilizar algumas das bibliotecas mais detalhadas encontradas em várias linguagens de programação? Por que não criar a sua própria do zero? Porque trabalhar com criptomoedas é perigoso. Não há redes de segurança. Se você acidentalmente pagar taxas muito altas ou perder uma chave de assinatura ou criar uma transação inválida ou fazer qualquer outros milhares de erros potenciais, você dará adeus a suas moedas para sempre. Muito dessa responsabilidade, é claro, fica com você como sendo um programador de criptomoedas, mas também pode ser minimizado, trabalhando com as interfaces de criptomoedas mais robustas e seguras que estão disponíveis, as que foram criadas pelas próprias equipes de programação dessas criptomoedas: A ``Bitcoind`` e a ``Lightningd``. +Por que não usar algumas das bibliotecas mais completas encontradas em várias linguagens de programação? Por que não criar o seu próprio a partir do zero? É porque trabalhar com criptomoedas é perigoso. Não há redes de segurança. Se você acidentalmente pagar demais suas taxas ou perder uma chave de assinatura ou criar uma transação inválida ou cometer qualquer mínimo erro potencial, sua criptomoeda desaparecerá para sempre. Grande parte dessa responsabilidade, é claro, recairá sobre você como programador de criptomoedas, mas pode ser minimizada trabalhando com as interfaces de criptomoeda mais robusta, confiável e seguras, aquelas criadas pelas próprias equipes de programação de criptomoedas: ''bitcoind'' e ''lightningd''. -Grande parte deste livro discute como fazer um script em bitcoin (e na Lightning Network) diretamente pela linha de comando. Alguns capítulos adiantes lidam com linguagens de programação mais sofisticadas, mas novamente continuam a interagir diretamente com o `` Bitcoind`` e a ``Lightningd``, usando o RPC ou interagindo com os arquivos que são criados por eles. Isso permite que você se mantenha no mesmo nível dos gigantes e use a tecnologia confiável para aprender como criar seus próprios sistemas confiáveis. +Grande parte deste livro, portanto, discute como manipular Bitcoin com scripts (e Lightning) diretamente da linha de comando. Alguns capítulos posteriores lidam com linguagens de programação mais sofisticadas, mas novamente eles continuam a interagir diretamente com os serviços ''bitcoind'' e ''lightningd'' usando RPC ou interagindo com os arquivos que eles criam. Isso permite que você fique sobre os ombros de gigantes e use sua tecnologia confiável para aprender a criar seus próprios sistemas confiáveis. ## Nível de Habilidade Necessária @@ -39,11 +39,11 @@ Então, por onde você começa? Este livro é destinado principalmente para ser Se você tem diferentes níveis de habilidade ou se quiser aprender coisas diferentes, poderá pular para algumas partes diferentes do livro: * Se você já tem um ambiente pronto do Bitcoin para ser utilizado, vá para o [Capítulo 3: Compreendendo Nossa Configuração do Bitcoin](03_0_Understanding_Your_Bitcoin_Setup.md). -* Se você só se importa com programar no Bitcoin, pule para o [Capítulo 9: Apresentando os Scripts do Bitcoin](09_0_Introducing_Bitcoin_Scripts.md). -* Se você quiser apenas ler sobre o uso das linguagens de programação, pule para o [Capítulo 16: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md). -* Se não quer programar nada, definitivamente ignore os capítulos 16 ao 18 enquanto estiver lendo, e talvez seja melhor pular os capítulos 9 ao 13. O resto do curso ainda deve fazer sentido sem eles. +* Se você só se importa com programar através de scripts no Bitcoin, pule para o [Capítulo 9: Apresentando os Scripts do Bitcoin](09_0_Introducing_Bitcoin_Scripts.md). +* Se você quiser apenas ler sobre o uso das linguagens de programação, pule para o [Capítulo 16: Conversando com o Bitcoind](16_0_Talking_to_Bitcoind.md). +* Se não quer programar nada, definitivamente ignore os capítulos 15 ao 17 enquanto estiver lendo, e talvez seja melhor pular os capítulos 9 ao 13. O resto do curso ainda deve fazer sentido sem eles. * Se estiver interessado apenas na Lightning Network, corra para o [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md). -* Se quiser ler o conteúdo novo adicionado na versão 2 do curso (2020), seguido da versão 1 (2017), leia [§3.5: Entendendo o Descritor](03_5_Understanding_the_Descriptor.md), [§4.6: Criando uma Transação SegWit](04_6_Creating_a_Segwit_Transaction.md), [Capítulo 7: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md), [§9.5: Programando um P2WPKH](09_5_Scripting_a_P2WPKH.md), [§10.5: Programando um Script SegWit](10_5_Scripting_a_Segwit_Script.md), [Capítulo 14: Usando o Tor](14_0_Using_Tor.md), [Capítulo 16: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md), [Capítulo 17: Programando o Bitcoin com Libwally](17_0_Programming_with_Libwally.md), [Capítulo 18: Conversando com o Bitcoind com Outras Linguagens](18_0_Talking_to_Bitcoind_Other.md), [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md), e [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md). +* Se quiser ler o conteúdo novo adicionado na versão 2 do curso (2020), seguido da versão 1 (2017), leia [§3.5: Entendendo o Descritor](03_5_Understanding_the_Descriptor.md), [§4.6: Criando uma Transação SegWit](04_6_Creating_a_Segwit_Transaction.md), [Capítulo 7: Expandindo Transações no Bitcoin com PSBTs](07_0_Expanding_Bitcoin_Transactions_PSBTs.md), [§9.5: Programando um P2WPKH](09_5_Scripting_a_P2WPKH.md), [§10.5: Programando um Script SegWit](10_5_Scripting_a_Segwit_Script.md), [Capítulo 14: Usando o Tor](14_0_Using_Tor.md), ), [Capítulo 14: Usando o i2p](14_0_Using_i2p.md) [Capítulo 16: Conversando com o Bitcoind com C](16_0_Talking_to_Bitcoind.md), [Capítulo 17: Programando o Bitcoin com Libwally](17_0_Programming_with_Libwally.md), [Capítulo 18: Conversando com o Bitcoind com Outras Linguagens](18_0_Talking_to_Bitcoind_Other.md), [Capítulo 19: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md), e [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md). ## Por Que Utilizar Este Curso @@ -58,6 +58,6 @@ Obviamente, você está querendo fazer este curso porque está interessado no Bi ## O Que Vem Depois? -Se você quiser uma introdução básica ao Bitcoin, criptografia de chave pública, ECC, blockchains e Lightning Network, leia o prefácio [Apresentando o Bitcoin](01_1_Introducing_Bitcoin.md). +Se você quiser uma introdução básica ao Bitcoin, criptografia de chave pública, ECC, blockchains e Lightning Network, leia o interlúdio [Apresentando o Bitcoin](01_1_Introducing_Bitcoin.md). Caso contrário, se já estiver pronto para mergulhar de cabeça no curso, vá para [Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md). diff --git a/pt/01_1_Introducing_Bitcoin.md b/pt/01_1_Introducing_Bitcoin.md index 94fc13625..5351b1b91 100644 --- a/pt/01_1_Introducing_Bitcoin.md +++ b/pt/01_1_Introducing_Bitcoin.md @@ -1,28 +1,28 @@ -# Prefácio: Apresentando o Bitcoin +# Prefácio: Apresentando o Bitcoin Antes de começar a programar em Bitcoin (e Lightning), você deve ter uma compreensão básica do que são e como funcionam. Esta seção fornece essa visão geral. Várias outras definições irão aparecer mais à frente. O objetivo deste capítulo é apenas dar o conteúdo base. ## Sobre o Bitcoin -O Bitcoin é um sistema programável que permite a transferência da moeda bitcoin. Tem como base um sistema descentralizado _peer-to-peer_ (de ponta à ponta) de nodes, que inclui full nodes, carteiras e mineradores. Trabalhando juntos, eles garantem que as transações do bitcoin sejam rápidas e irreversíveis. Graças à natureza descentralizada do sistema, essas transações também são resistentes à censura e podem fornecer outras vantagens, como pseudo-anonimato, caso sejam bem utilizadas. +O Bitcoin é um sistema programável que permite a transferência da moeda bitcoin. Tem como base um sistema descentralizado, peer-to-peer (de ponta à ponta) de nodes (nós), que inclui full nodes (nós completos), carteiras e mineradores. Trabalhando juntos, eles garantem que as transações do bitcoin sejam rápidas e irreversíveis. Graças à natureza descentralizada do sistema, essas transações também são resistentes à censura e podem fornecer outras vantagens, como pseudo-anonimato, caso sejam bem utilizadas. -Obviamente, Bitcoin é o coração deste livro, mas também é o originador de muitos outros sistemas, incluindo a blockchain e Lightning, que são detalhados neste tutorial, e muitas outras criptomoedas, como Ethereum e Litecoin, que não são. +Obviamente, Bitcoin é o coração deste livro, mas também é o originador de muitos outros sistemas, incluindo a blockchain (cadeia de blocos) e Lightning, que são detalhados neste tutorial, e muitas outras criptomoedas, como Ethereum e Litecoin, que não são. **_Como as moedas são transferidas?_** O Bitcoin não possui moedas físicas. Elas são uma série interminável de trocas títulos de propriedade. Quando uma pessoa envia as moedas para outra, essa transferência é armazenada como uma transação. É a transação que realmente registra a propriedade do dinheiro, isso significa que não existe nenhuma moeda que sai da carteira ou da máquina do proprietário. -**_Para quem você pode enviar as moedas?_** A grande maioria das transações de bitcoin envolvem o envio de moedas para pessoas comuns (ou pelo menos para endereços Bitcoin de pessoas comuns). No entanto, metodologias mais complexas podem ser usadas para enviar bitcoins para um grupo de pessoas ou para scripts. Essas várias metodologias possuem nomes como P2PKH, multisig e P2SH. +**_Para quem você pode enviar as moedas?_** A grande maioria das transações de bitcoin envolvem o envio de moedas para algum indivíduo (ou pelo menos para endereços Bitcoin de algum indivíduo). No entanto, metodologias mais complexas podem ser usadas para enviar bitcoins para um grupo de pessoas ou para scripts. Essas várias metodologias possuem nomes como P2PKH, multisig e P2SH. -**_Como as transações são armazenadas?_** As transações são combinadas em grandes blocos de dados, que são gravados na _ledger da blockchain_. Um bloco é construído de tal forma que não pode ser substituído ou reescrito, uma vez que vários blocos tenham sido construídos depois dele. Isso é o que torna os bitcoins irreversíveis: Um livro razão (_ledger_) global descentralizado, onde tudo é registrado, é efetivamente um banco de dados permanente e imutável. +**_Como as transações são armazenadas?_** As transações são combinadas em grandes blocos de dados, que são gravados na livro-caixa blockchain. Um bloco é construído de tal forma que não pode ser substituído ou reescrito, uma vez que vários blocos tenham sido construídos com base nele (depois dele). Isso é o que torna os bitcoins irreversíveis: isso é o que torna os bitcoins não repudiáveis: o livro-razão global descentralizado onde tudo é registrado é efetivamente um banco de dados permanente e imutável. -Porém, o processo de construção desses blocos é estocástico: É um tanto aleatório, então não podemos ter certeza se uma transação será colocada em um bloco específico. Também pode haver alterações nos blocos se forem muito recentes, mas apenas se forem _muitíssimo_ recentes. Então, as coisas se tornam irreversíveis (permanentes, imutáveis) depois de um alguns minutos. +Porém, o processo de construção desses blocos é estocástico: É um tanto aleatório, então não podemos ter certeza se uma transação será colocada em um bloco específico. Também pode haver alterações nos blocos se forem muito recentes, mas apenas se forem _muitíssimo_ recentes. Então, as coisas se tornam irreversíveis (permanentes, imutáveis) depois de algum tempo. -**_Como as transações são protegidas?_** Os fundos contidos em uma transação Bitcoin são assegurados por um quebra-cabeça criptográfico. Esses quebra-cabeças são projetados para que possam ser facilmente resolvidos pela pessoa para quem os fundos foram enviados. Isso é feito usando o poder da criptografia de chave pública. Tecnicamente, uma transação é protegida por uma assinatura que prova que você é o proprietário da chave pública para a qual a transação foi enviada: Essa prova de propriedade é o quebra-cabeça que está sendo resolvido. +**_Como as transações são protegidas?_** Os fundos contidos em uma transação Bitcoin são assegurados por um quebra-cabeça criptográfico. Esses quebra-cabeças são projetados para que possam ser facilmente resolvidos pela pessoa para quem os fundos a serem enviados. Isso é feito usando o poder da criptografia de chave pública. Tecnicamente, uma transação é protegida por uma assinatura que prova que você é o proprietário da chave pública para a qual a transação foi enviada: Essa prova de propriedade é o quebra-cabeça que está sendo resolvido. Os fundos são protegidos pelo uso de hashes. As chaves públicas não são realmente armazenadas na blockchain até que os fundos sejam gastos: Apenas os hashes de chave pública são. Isso significa que, mesmo que um computador quântico seja criado, as transações do Bitcoin permaneceriam protegidas por esse segundo nível de criptografia. -**_Como as transações são criadas?_** O coração de cada transação do Bitcoin é uma linguagem script do tipo FORTH usada para bloquear a transação. Para reenviar o dinheiro, o destinatário fornece informações específicas ao script que prova que ele é o destinatário pretendido. +**_Como as transações são criadas?_** O coração de cada transação Bitcoin é uma linguagem de script semelhante ao FORTH que é usada para bloquear a transação. Para gastar novamente o dinheiro, o destinatário fornece informações específicas ao script que provam que ele é o destinatário pretendido. -No entanto, esses scripts do Bitcoin são o nível mais baixo de funcionalidade deste protocolo. Grande parte do trabalho do Bitcoin é feito através do `bitcoind` do Bitcoin, que é controlado por meio de comandos RPC. Muitas pessoas enviam esses comandos RPC por meio do programa chamado `bitcoin-cli`, que fornece uma interface ainda mais simples. Os não programadores nem mesmo se preocupam com essas minúcias, permitindo o uso de carteiras programáveis com interfaces mais simples. +No entanto, esses scripts Bitcoin são o nível mais baixo de funcionalidade Bitcoin. Muito do trabalho do Bitcoin é feito através do daemon Bitcoin 'bitcoind', que é controlado através de comandos RPC. Muitas pessoas enviam esses comandos RPC através do programa 'bitcoin-cli', que fornece uma interface ainda mais simples. Os não-programadores nem se preocupam com essas minúcias, mas usam carteiras programadas com interfaces mais simples. ### Bitcoin –– Em Resumo @@ -124,7 +124,7 @@ A Lightning é um protocolo de segunda camada que interage com o Bitcoin para pe A Lightning também é um dos focos deste tutorial. Embora o ponto principal seja sobre a interação direta com o Bitcoin (e o `bitcoind`), vamos falar um pouco sobre a Lightning e o porque é uma tecnologia que está prestes a se tornar uma alternativa popular ao Bitcoin, em um futuro próximo. Este livro tem a mesma abordagem para a Lightning e para o Bitcoin: Ele ensina como interagir diretamente com a Lightning de maneira confiável à partir da linha de comando. -Ao contrário do Bitcoin, existem várias variantes da Lightning. Este tutorial usa a implementação compatível do padrão [c-lightning](https://github.com/ElementsProject/lightning) como sendo seu servidor Lightning confiável. +Ao contrário do Bitcoin, existem várias variantes da Lightning. Este tutorial usa a implementação compatível do padrão [core lightning](https://github.com/ElementsProject/lightning) como sendo seu servidor Lightning confiável. **_O que é um protocolo de segunda camada?_** Um protocolo de segunda camada no Bitcoin funciona tendo como base o Bitcoin. Nesse caso, a Lightning trabalha em cima do Bitcoin, interagindo com ele por meio de contratos inteligentes. @@ -146,4 +146,4 @@ O Bitcoin é um sistema _peer-to-peer_ que permite a transferência de fundos po ## O Que Vem Depois? -Vamos avançar em "Se Prepararando para o Bitcoin" com o [Capítulo Dois: Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md). \ No newline at end of file +Vamos avançar em "Se Prepararando para o Bitcoin" com o [Capítulo Dois: Configurando um Bitcoin-Core VPS](02_0_Setting_Up_a_Bitcoin-Core_VPS.md). diff --git a/pt/19_0_Understanding_Your_Lightning_Setup.md b/pt/19_0_Understanding_Your_Lightning_Setup.md index 4edcb98be..41fcb1ab2 100644 --- a/pt/19_0_Understanding_Your_Lightning_Setup.md +++ b/pt/19_0_Understanding_Your_Lightning_Setup.md @@ -2,13 +2,13 @@ > :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. +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 core 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; + * Avaliar se um node core lightning está instalado e atualizado; * Executar comandos básicos de uma carteira Lightning; * Criar um canal na Lightning. @@ -20,7 +20,7 @@ Os objetivos secundários do capítulo incluem a capacidade de: ## Tabela de Conteúdo -* [Seção 1: Verificando Nossa Configuração da c-lightning](19_1_Verifying_Your_Lightning_Setup.md) -* [Seção 2: Conhecendo Nossa Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md) +* [Seção 1: Verificando Nossa Configuração da core lightning](19_1_Verifying_Your_Lightning_Setup.md) +* [Seção 2: Conhecendo Nossa Configuração da core 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 Lightning](19_3_Setting_Up_a_Channel.md) \ No newline at end of file +* [Seção 3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md) diff --git a/pt/19_1_Verifying_Your_Lightning_Setup.md b/pt/19_1_Verifying_Your_Lightning_Setup.md index 1fb81ba32..38e27f95d 100644 --- a/pt/19_1_Verifying_Your_Lightning_Setup.md +++ b/pt/19_1_Verifying_Your_Lightning_Setup.md @@ -1,14 +1,14 @@ -# 19.1: Verificando Nossa Configuração da c-lightning +# 19.1: Verificando Nossa Configuração da core 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 a c-lightning, nosso utilitário para acessar a Lightning Network. +Nesta seção, instalaremos e verificaremos a core 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 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 "off-chain". -## Instalando a c-lightning +## Instalando a core 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 isto verificando se o `lightningd` está em execução: ``` @@ -27,15 +27,15 @@ standup 32072 0.0 0.0 6208 888 pts/0 S+ 15:50 0:00 grep -i lightni ``` 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 [projeto Elements](https://github.com/ElementsProject), que contém a Libwally. +> :book: ***O que é a core lightning?*** Existem três implementações diferentes da Lightning no momento: core 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 core 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 core 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, 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 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. +> :warning: **AVISO:** Realmente podemos executar a core 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: @@ -94,7 +94,7 @@ A bitcoin lightning daemon (default values shown for network: testnet). 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 a `c-lightning` manualmente, precisaremos iniciá-la: +Se instalamos a `core lightning` manualmente, precisaremos iniciá-la: ``` $ nohup lightningd --testnet & ``` @@ -227,12 +227,12 @@ bitcoin-cli -testnet getblock 0000000000000559febee77ab6e0be1b8d0bef0f971c7a4bee ## Criando Aliases -Sugerimos a criação de alguns aliases (apelidos de comandos) para facilitar o uso da c-lightning. +Sugerimos a criação de alguns aliases (apelidos de comandos) para facilitar o uso da core lightning. Podemos fazer isso colocando-os em nosso arquivo `.bash_profile`. ``` cat >> ~/.bash_profile < :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 a nossa configuração. -## Conhecendo o Diretório da c-lightning +## Conhecendo o Diretório da core lightning -Ao usar a c-lightning, tudo será mantindo dentro do diretório `~/.lightning`. +Ao usar a core 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: ``` @@ -329,7 +329,7 @@ c$ lightning-cli --testnet listconfigs } ``` -## Resumo: Conhecendo Nossa Configuração da c-lightning +## Resumo: Conhecendo Nossa Configuração da core lightning O diretório `~/.lightning` contém todos os arquivos, enquanto o comando `lightning-cli help` mostra uma variedade de informações dos comandos que podem ser usados para obter mais informações sobre a configuração e o funcionamento da Lightning Network. @@ -337,4 +337,4 @@ O diretório `~/.lightning` contém todos os arquivos, enquanto o comando `light Precisaremos de um segundo node para testar o pagamento dos invoices. Se precisarmos de suporte para configurar um, podemos ler o [Prefácio: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). -Caso contrário, vamos continuar "Compreendendo a Configuração da Lightning" na seção [§19.3: Criando um Canal na Lightning](19_3_Setting_Up_a_Channel.md). \ 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). 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 a0c9af22b..f138c3468 100644 --- a/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md +++ b/pt/19_2__Interlude_Accessing_a_Second_Lightning_Node.md @@ -10,7 +10,7 @@ Existem quatro maneiras de fazermos isso (das quais as três primeiras são poss Se outra pessoa já tiver um node da Lightning Network na rede que escolhemos, podemos pedir o ID dele. -Se estiverem executando a c-lightning, eles só precisam usar o comando `getinfo`: +Se estiverem executando a core 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! @@ -50,9 +50,9 @@ lightning-cli: WARNING: default network changing in 2020: please set network=tes ``` 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 core 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 [§19.1](19_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 core 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. @@ -109,7 +109,7 @@ $ sudo cp $GOPATH/bin/lnd $GOPATH/bin/lncli /usr/bin ### Criando um Arquivo de Configuração do LND -Ao contrário da c-lightning, precisaremos criar um arquivo de configuração padrão para o LND. +Ao contrário da core 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 [§16.3](16_3_Receiving_Bitcoind_Notifications_with_C.md). @@ -213,7 +213,7 @@ $ sudo systemctl start lnd ### Habilitando Conexões Remotas -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: +Assim como na core 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 ``` @@ -317,10 +317,10 @@ No entanto, este definitivamente não será o caso na nossa primeira interação ## Resumo: Prefácio: Acessando um Segundo Node Lightning -Sempre precisaremos de dois nodes Lightning para formar um canal. Se não tivermos outra pessoa que está testando as coisas conosco, precisaremos criar um segundo node, usanda c-lightning ou (como faremos em nossos exemplos) usando a LND. +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 core lightning ou (como faremos em nossos exemplos) usando a LND. ## O Que Vem Depois? -Embora possivelmente tenhamos criado um LND, a c-lightning permanecerá no centro dos nossos exemplos até que precisemos começar a usar os dois, no [Capítulo 20](20_0_Using_Lightning.md). +Embora possivelmente tenhamos criado um LND, a core lightning permanecerá no centro dos nossos exemplos até que precisemos começar a usar os dois, no [Capítulo 20](20_0_Using_Lightning.md). Vamos continuar "Compreendendo Nossa Configuração da Lightning" na seção [§19.3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md). diff --git a/pt/19_3_Setting_Up_a_Channel.md b/pt/19_3_Setting_Up_a_Channel.md index 3acb9312f..eb25f7c7b 100644 --- a/pt/19_3_Setting_Up_a_Channel.md +++ b/pt/19_3_Setting_Up_a_Channel.md @@ -2,29 +2,29 @@ > :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 ele é e como é criado usando a 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 core 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 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çãa c-lightning como nosso node principal. +Nesta seção, continuaremos usando nossa configuraçãa core 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; +* Financiar nossa carteira core lightning com alguns satoshis; * Conectar-se a um node remoto como um par; * Abrir um canal. -### Financiando Nossa Carteira c-lightning +### Financiando Nossa Carteira core lightning -Para mover fundos para um canal Lightning, primeiro é necessário financiar nossa carteira c-lightning. +Para mover fundos para um canal Lightning, primeiro é necessário financiar nossa carteira core lightning. -> :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. +> :book: ***O que é uma carteira core lightning?*** A implementação padrão da core 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`. 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. +A primeira coisa que precisamos fazer é enviar alguns satoshis para nossa carteira core 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 core 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 @@ -74,15 +74,15 @@ 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. +Agora que financiamos nossa carteira core 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 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). +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 core 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: +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 core lightning: ``` $ lightning-cli --network=testnet connect 032a7572dc013b6382cde391d79f292ced27305aa4162ec3906279fc4334602543@45.33.35.151 @@ -182,4 +182,4 @@ Precisaremos criar um canal com um node remoto para poder receber e enviar dinhe ## O Que Vem Depois? -Você está pronto para passar para o [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md). \ No newline at end of file +Você está pronto para passar para o [Capítulo 20: Usando a Lightning](20_0_Using_Lightning.md). diff --git a/pt/20_1_Generate_a_Payment_Request.md b/pt/20_1_Generate_a_Payment_Request.md index 312e00863..f1a58faec 100644 --- a/pt/20_1_Generate_a_Payment_Request.md +++ b/pt/20_1_Generate_a_Payment_Request.md @@ -2,15 +2,15 @@ > :information_source: **NOTA:** Esta seção foi adicionada recentemente ao curso e é um rascunho inicial que ainda pode estar aguardando revisão. -Esta seção descreve como os pagamentos funcionam na Lightning Network, como criar uma solicitação de pagamento (ou _invoice_) e, finalmente, como entendê-la. A emissão de invoices depende de termos um segundo node Lightning, conforme descrito na seção [Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). Esses exemplos usarão um node LND como nosso node secundário, para demonstrar ainda mais as possibilidades da Lightning Network. Para diferenciar entre os nodes nestes exemplos, os prompts serão mostrados como `c $` para o node c-lightning e `lnd $` para o node LND. Se quisermos reproduzir essas etapas, devemos [instalar nosso próprio node LND secundário](19_2__Interlude_Accessing_a_Second_Lightning_Node.md#Creating-a-new-lnd-node). +Esta seção descreve como os pagamentos funcionam na Lightning Network, como criar uma solicitação de pagamento (ou _invoice_) e, finalmente, como entendê-la. A emissão de invoices depende de termos um segundo node Lightning, conforme descrito na seção [Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md). Esses exemplos usarão um node LND como nosso node secundário, para demonstrar ainda mais as possibilidades da Lightning Network. Para diferenciar entre os nodes nestes exemplos, os prompts serão mostrados como `c $` para o node core lightning e `lnd $` para o node LND. Se quisermos reproduzir essas etapas, devemos [instalar nosso próprio node LND secundário](19_2__Interlude_Accessing_a_Second_Lightning_Node.md#Creating-a-new-lnd-node). > :book: ***O que é um invoice?*** Quase todos os pagamentos feitos na Lightning Network exigem um invoice, que nada mais é do que um **pedido de pagamento** feito pelo destinatário do dinheiro e enviado por qualquer meio para o usuário que irá pagar. Todos os invoices são de uso único. Os invoices da Lightning usam a codificação bech32, que já é usada pela Segregated Witness para Bitcoin. ## Criando um Invoice -Para criar um novo invoice na c-lightning, usaríamos o comando `lightning-cli --testnet invoice`. +Para criar um novo invoice na core lightning, usaríamos o comando `lightning-cli --testnet invoice`. -Vamos ver como funcionaria com o c-lightning, usando argumentos de um valor (em milisats), um rótulo e uma descrição. +Vamos ver como funcionaria com o core lightning, usando argumentos de um valor (em milisats), um rótulo e uma descrição. ``` c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for dinner" { @@ -21,7 +21,7 @@ c$ lightning-cli --testnet invoice 100000 joe-payment "The money you owe me for "warning_mpp_capacity": "The total incoming capacity is still insufficient even if the payer had MPP capability." } ``` -No entanto, para este exemplo, vamos gerar um invoice em um node LND e, em seguida, pagá-lo no node c-lightning. Isso requer o comando `addinvoice` ligeiramente diferente na LND. Podemos usar o argumento `--amt` para indicar a quantia a ser paga (em milisats) e adicionar uma descrição usando o argumento `--memo`. +No entanto, para este exemplo, vamos gerar um invoice em um node LND e, em seguida, pagá-lo no node core lightning. Isso requer o comando `addinvoice` ligeiramente diferente na LND. Podemos usar o argumento `--amt` para indicar a quantia a ser paga (em milisats) e adicionar uma descrição usando o argumento `--memo`. ``` lnd$ lncli -n testnet addinvoice --amt 10000 --memo "First LN Payment - Learning Bitcoin and Lightning from the Command line." @@ -181,4 +181,4 @@ Na maioria dos casos, precisamos receber um invoice para usar os pagamentos da L ## O Que Vem Depois? -Vamos continuar "Usando a Lightning" na seção [§20.2: Pagando um Invoice](20_2_Paying_a_Invoice.md). \ No newline at end of file +Vamos continuar "Usando a Lightning" na seção [§20.2: Pagando um Invoice](20_2_Paying_a_Invoice.md). diff --git a/pt/20_3_Closing_a_Channel.md b/pt/20_3_Closing_a_Channel.md index 5f66157b0..50e417b4a 100644 --- a/pt/20_3_Closing_a_Channel.md +++ b/pt/20_3_Closing_a_Channel.md @@ -177,7 +177,7 @@ $ bitcoin-cli --named getrawtransaction txid=f68de52d80a1076e36c677ef640539c50e3 "blocktime": 1602713519 } ``` -A entrada da transação é `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, que foi a transação de financiamento feita na seção [§19.3](19_3_Setting_Up_a_Channel.md). A transação tem duas saídas, uma para o node remoto e outra para a carteira local da c-lightning. A saída no índice 0 corresponde ao node remoto com um valor de 0,00010012 BTC e, a saída no índice 1 corresponde ao node local com um valor de 0,00089804 BTC. +A entrada da transação é `66694d23ca15efe379e5f4a71d9be1a2d65e383b89ee3abe126ee36a12f23c1d`, que foi a transação de financiamento feita na seção [§19.3](19_3_Setting_Up_a_Channel.md). A transação tem duas saídas, uma para o node remoto e outra para a carteira local da core lightning. A saída no índice 0 corresponde ao node remoto com um valor de 0,00010012 BTC e, a saída no índice 1 corresponde ao node local com um valor de 0,00089804 BTC. A Lightning mostrará da mesma forma 89.804 satoshis retornados como um novo UTXO em nossa carteira: @@ -256,4 +256,4 @@ Ao fechar um canal, realizamos uma transação na blockchain encerrando nosso re ## O Que Vem Depois? -Vamos continuar "Usando a Lightning" na seção [§20.4: Expandindo a Lightning Network](20_4_Lightning_Network_Review.md). \ No newline at end of file +Vamos continuar "Usando a Lightning" na seção [§20.4: Expandindo a Lightning Network](20_4_Lightning_Network_Review.md). diff --git a/pt/20_4_Lightning_Network_Review.md b/pt/20_4_Lightning_Network_Review.md index bed52ba1d..4724b7ed9 100644 --- a/pt/20_4_Lightning_Network_Review.md +++ b/pt/20_4_Lightning_Network_Review.md @@ -4,9 +4,9 @@ Esses dois capítulos cobriram apenas algumas das atividades mais importantes da Lightning. Há muito mais que pode ser feito e muitas variedades possíveis. A seguir, daremos algumas dicas importantes. -## Usando Plugins c-lightning +## Usando Plugins core lightning -O c-lightning é uma implementação leve, altamente personalizável e compatível com o padrão do protocolo Lightning Network. Ele estende a funcionalidade usando plugins. Principalmente, esses são subprocessos que são iniciados pelo daemon `lightningd` e podem interagir com o `lightningd` de várias maneiras: +O core lightning é uma implementação leve, altamente personalizável e compatível com o padrão do protocolo Lightning Network. Ele estende a funcionalidade usando plugins. Principalmente, esses são subprocessos que são iniciados pelo daemon `lightningd` e podem interagir com o `lightningd` de várias maneiras: * As opções de linha de comando permitem que os plugins registrem os próprios argumentos usando a linha de comando, que são então expostos por meio do `lightningd`; * A passagem de comando JSON-RPC permite que os plugins adicionem os próprios comandos à interface JSON-RPC; @@ -19,19 +19,19 @@ O repositório `lightningd` GitHub mantém uma lista atualizada de [plugins](htt ## Usando Carteiras Mobile -Atualmente, sabemos de duas carteiras de dispositivos móveis da Lightning que suportam a implementação do c-lightning. +Atualmente, sabemos de duas carteiras de dispositivos móveis da Lightning que suportam a implementação do core lightning. Para dispositivos iOS, o FullyNoded é uma carteira de Bitcoin iOS open source que se conecta através do serviço autenticado Tor V3 ao nosso próprio full node. A funcionalidade FullyNoded está atualmente em desenvolvimento ativo e na fase beta inicial de testes. * [FullyNoded](https://github.com/Fonta1n3/FullyNoded/blob/master/Docs/Lightning.md) -O SparkWallet é uma carteira GUI minimalista para a c-lightning, acessível pela web ou por meio de aplicativos móveis e de desktop para Android. +O SparkWallet é uma carteira GUI minimalista para a core lightning, acessível pela web ou por meio de aplicativos móveis e de desktop para Android. * [SparkWallet](https://github.com/shesek/spark-wallet) ## Usando Diferentes Implementações da Lightning -O c-lightning não é a nossa única opção. Hoje, existem três implementações amplamente utilizadas para a Lightning Network. Todos seguem as [Documentações Base para a Tecnologia Lightning (BOLT)](https://github.com/lightningnetwork/lightning-rfc), que descrevem um protocolo de segunda camada para transferências de bitcoins off-chain. As especificações são atualmente um trabalho em andamento que ainda está sendo elaborado. +O core lightning não é a nossa única opção. Hoje, existem três implementações amplamente utilizadas para a Lightning Network. Todos seguem as [Documentações Base para a Tecnologia Lightning (BOLT)](https://github.com/lightningnetwork/lightning-rfc), que descrevem um protocolo de segunda camada para transferências de bitcoins off-chain. As especificações são atualmente um trabalho em andamento que ainda está sendo elaborado. | Nome | Descrição | BitcoinStandup | Linguagem | Repositório | | ------------- | ------------- | :---: | ------------- | ------------- | @@ -57,4 +57,4 @@ Caso contrário, nós o encorajamos a ingressar nas comunidades de desenvolvedor Você também pode nos ajudar aqui na Blockchain Commons com issues ou PRs para Aprendendo Bitcoin ou para qualquer um de nossos outros repositórios, ou pode até mesmo se tornar um [patrocinador](https://github.com/sponsors/BlockchainCommons). Também pode ajudar divulgando o trabalho, contando às pessoas nas redes sociais sobre o curso e o que aprendeu com ele! -Agora vá lá e faça da comunidade do Bitcoin um lugar melhor! \ No newline at end of file +Agora vá lá e faça da comunidade do Bitcoin um lugar melhor! diff --git a/pt/README.md b/pt/README.md index 3e81ca03d..87393c11b 100644 --- a/pt/README.md +++ b/pt/README.md @@ -134,8 +134,8 @@ Se você gostaria de fazer a sua própria tradução, por favor veja [Contribuin **Estado:** Finalizado. * [19.0: Compreendendo Nossa Configuração da Lightning](19_0_Understanding_Your_Lightning_Setup.md) - * [19.1: Verificando Nossa Configuração da c-lightning](19_1_Verifying_Your_Lightning_Setup.md) - * [19.2: Conhecendo Nossa Configuração da c-lightning](19_2_Knowing_Your_lightning_Setup.md) + * [19.1: Verificando Nossa Configuração da core lightning](19_1_Verifying_Your_Lightning_Setup.md) + * [19.2: Conhecendo Nossa Configuração da core lightning](19_2_Knowing_Your_lightning_Setup.md) * [Prefácio: Acessando um Segundo Node Lightning](19_2__Interlude_Accessing_a_Second_Lightning_Node.md) * [19.3: Criando um Canal Lightning](19_3_Setting_Up_a_Channel.md) * [20.0: Usando a Lightning](20_0_Using_Lightning.md) diff --git a/src/04_2_i_txfee-calc.sh b/src/04_2_i_txfee-calc.sh index 64a884a23..62a29a34a 100644 --- a/src/04_2_i_txfee-calc.sh +++ b/src/04_2_i_txfee-calc.sh @@ -1,6 +1,6 @@ #!/bin/bash -if [ -z $1 ]; +if [ -z "$1" ]; then echo "You must include the raw transaction hex as an argument."; exit; @@ -11,4 +11,4 @@ usedvout=($(bitcoin-cli decoderawtransaction $1 | jq -r '.vin | .[] | .vout')) btcin=$(for ((i=0; i<${#usedtxid[*]}; i++)); do txid=${usedtxid[i]}; vout=${usedvout[i]}; bitcoin-cli listunspent | jq -r '.[] | select (.txid | contains("'${txid}'")) | select(.vout | contains('$vout')) | .amount'; done | awk '{s+=$1} END {print s}') btcout=$(bitcoin-cli decoderawtransaction $1 | jq -r '.vout [] | .value' | awk '{s+=$1} END {print s}') btcout_f=$(awk -v btcout="$btcout" 'BEGIN { printf("%f\n", btcout) }'