Output descriptors are simple, human-readable strings that fully describe a set of Bitcoin addresses. Descriptors offer a user-friendly approach to managing scriptPubKey, the script that controls how a Bitcoin output can be spent. They contain all the information needed to “solve” (spend) the associated script. This format was proposed to improve upon the existing methods of address generation, which often lacked consistency and required additional information to reproduce accurately.

Descriptors are visible with several commands such as listunspent and getaddressinfo For instance;

$ bitcoin-cli getaddressinfo youraddress
{
  "address": "str",
  "scriptPubKey": "hex",
  "ismine": true|false,
  "solvable": true|false,
  "desc": "str",
  "iswatchonly": true|false,
  "isscript": true|false,
  "iswitness": true|false,
  "pubkey": "hex",
  "iscompressed": true|false,
  "ischange": true|false,
  "timestamp": xxx, // numeric
  "hdkeypath": "str",
  "hdseedid": "hex",
  "hdmasterfingerprint": "hex",
  "labels": [
    "str"
  ]
}

The "desc" field shows the descriptor of an address.

Example of an output descriptor:

pkh([d34db33f/44'/0'/0']03efdee34c0009fd175f3b20b5e5a5517fd5d16746f2e635b44617adafeaebc388)#4ahsl9pk

A descriptor is broken into several parts as seen below;

function([derivation-path]key)#checksum

Function: This is the function that is used to create an address from a given key. In this case, we have pkh, which is the standard P2PKH legacy address. Similarly, a P2PK address would use pk and a P2WPKH address would use wpkh.

Derivation Path: This describes the specific component being exported from an HD wallet. In our example above, it’s a seed with a fingerprint d34db33f followed by the 0th child of the 0th child of the 44th child (44'/0'/0') of that seed.

It’s important to highlight that while derivation paths typically include a fingerprint, you can make it up if it's not provided. However, maintaining consistency with an existing fingerprint is crucial, as it ensures compatibility when returning to the device that generated it.

Key: This refers to the essential data being transferred, which could be a single key or a set of keys. These keys might take various forms, such as an extended public or private key, a public key associated with an address, or a collection of addresses for a multi-signature setup. Regardless of the specific type, these keys serve as the foundational information for the transfer, while the function outlines how to utilize them.

Checksum: Descriptors are supposed to be human-transferrable. Attaching a checksum to descriptors protects against typos or copy-paste errors. Every RPC (Remote Procedure Call) in Bitcoin Core will include the checksum in its output. However, only specific RPCs, like deriveaddresses and importmultirequire checksums on input. In cases where a descriptor lacks a checksum, you can compute it using the getdescriptorinfo RPC.

Usage

Output descriptors are used in several key areas of Bitcoin wallet management:

• Address Generation: Wallets use descriptors to generate addresses according to the specified script and derivation rules.
• Wallet Import and Export: Descriptors can be used to export wallet information and import it into another wallet software without loss of fidelity.
• Backup: By backing up a descriptor along with seed phrases, users ensure they can recover not only their keys but also the exact wallet structure and script information.

Resources

• bitcoin/doc/descriptors.md at master · bitcoin/bitcoin
• What are output descriptors?
• RPC API Reference - Bitcoin

Imagine Bitcoin being able to hold more than just, well, Bitcoin. That’s the potential unlocked by Taproot Assets, a novel protocol that leverages the power of Taproot, a recent upgrade to the Bitcoin network.

What is Taproot Assets?

Taproot Assets is a Taproot-powered protocol for issuing digital assets on bitcoin that can be transferred over the Lightning Network for instant, high-volume, low-fee transactions. Unlike traditional Bitcoin transactions, which are relatively straightforward and transparent, Taproot enables complex smart contracts while enhancing privacy and efficiency. This advancement allows for the issuance and tranfer of various types of digital assets, including stablecoins (cryptocurrencies pegged to a stable asset like the US dollar), tokens, non-fungible tokens (NFTs), and decentralized finance (DeFi) instruments, among others.

Taproot Assets on Lightning Network

Taproot Assets is essentially an on-chain protocol. Assets are issued on the bitcoin blockchain using taproot transactions. However these assets can be transfered to the Lightning Network by depositing them into Lightning Network payment channels. This allows for instant transactions without bloating the bitcoin blockchain itself.

The core data about the assets is stored off-chain, while only a cryptographic fingerprint is placed on the blockchain. This keeps transaction fees low and speeds high.

As a Lightning Network user, you now have the option to maintain a wallet balance in a currency other than Bitcoin, such as a stablecoin. With this capability, you can receive payments in your preferred currency and utilize your stablecoin balance to conduct transactions for goods and services across the Lightning Network.

Bitcoin remains the backbone of the network. It handles the routing of payments, even those made with stablecoins. This clever integration allows for the smooth transmission of transactions over the existing Bitcoin Lightning Network infrastructure, eliminating the necessity for upgrades or additional opt-in procedures.

Why are Taproot Assets Important?

Taproot Assets has the potential to significantly expand the capabilities of the Bitcoin network. Here are some reasons why:

• Multi-Asset Functionality: Bitcoin can now potentially function like a platform for various digital assets, not just bitcoin itself.
• Lightning Network Integration: Taproot Assets can be seamlessly integrated with the Lightning Network, enabling fast, low-cost asset transfers.
• Scalability: By keeping most data off-chain, Taproot Assets avoids congesting the Bitcoin blockchain.

Still in its Early Stages

It’s important to remember that Taproot Assets is a relatively new technology. While it holds immense promise, there are still aspects to be ironed out. For instance, regulatory frameworks around digital assets are still evolving, posing potential risks for projects built on Taproot.

Conclusion

Taproot Assets represent a significant step forward in the evolution of Bitcoin. One of the key features of Taproot Assets is its ability to leverage the security and stability of the bitcoin network and the speed, scalability, and low fees of Lightning. By enabling a multi-asset future, it has the potential to unlock new use cases and expand Bitcoin’s reach. As the technology matures, it will be interesting to see how it shapes the future of the cryptocurrency landscape.

Resources

Taproot Assets | Builder's Guide

Bitcoin’s Taproot upgrade, activated in November 2021, marked a significant enhancement to the Bitcoin network. But what exactly is Taproot, and how does it impact Bitcoin transactions?

At its core, Taproot is a bundle of three advancements rolled into one. These advancements, known as Bitcoin Improvement Proposals (BIPs), work together to enhance Bitcoin’s efficiency, privacy, and functionality. Let’s delve into each BIP:

BIP 340 (Schnorr Signatures):

This BIP introduces the Schnorr signatures scheme, a cryptographic signature scheme that offers improvements in efficiency, security, and privacy compared to the traditional ECDSA (Elliptic Curve Digital Signature Algorithm) used in Bitcoin. The adoption of Schnorr signatures is a key component of the Taproot upgrade in Bitcoin, providing several benefits to the network.

The primary advantage of Schnorr signatures is that when multiple people sign a transaction, it looks just like a regular single-signature transaction on the network. Instead of revealing each person’s signature and public key separately, multiple signers produce a joint public key and then jointly sign with one signature, saving space on the blockchain. This not only makes transactions more private but also reduces the amount of data to be processed, especially beneficial as more people participate in a transaction. This reduces transaction size and verification time, leading to faster and cheaper transactions. This is a significant scalability and privacy enhancement.

BIP 341 (Taproot):

This BIP revamps Bitcoin’s scripting language, enabling more complex transactions like multi-signature spending and advanced smart contracts. Additionally, Taproot hides the complexity of these transactions, making them appear indistinguishable from regular transactions on the blockchain. This is achieved through Merklized Abstract Syntax Trees (MAST).

Imagine that you want to spend bitcoins from a P2SH address, you will need to produce the redeem script with the same hash value and include it in the transaction. This can make the transaction size very large if very many conditions are involved in this script. MAST provides a solution for this.

Merklized Abstract Syntax Trees are a combination of Merkle Trees and Abstract Syntax Trees. Just like Pay To Script Hash (P2SH) pays to a script matching the hash, MAST pays to the Merkle root’s hash.

With MAST, a hash tree of individual conditions that are part of a large condition set is created. A Merkle root is a single hash created by hashing all the conditions.

The illustration above shows four sets of spending conditions that are first hashed individually. Two hashes are then generated from those two pairs, which are again combined to create the final hash. This is called the Merkle root.

When unlocking unspent bitcoin, you need to generate a script that satisfies any branch of a Merkle tree. The Merkle root alone is sufficient to verify if the conditions match the original set. If the blockchain identifies that the script’s conditions are a part of this Merkle tree, it recognizes the coins that were locked using this script and proceeds to unlock them.

Therefore, you don’t have to create and include the entire script in the transaction, which reduces its size. This efficiency is achieved through Merklized Abstract Syntax Trees, as the Merkle root acts as a concise proof of inclusion, streamlining the verification process and enhancing the overall efficiency of Bitcoin transactions.

BIP 342 (Tapscript):

BIP 342 provides a more flexible scripting language, Tapscript, that builds upon BIP 341. Tapscript paves the way for future innovations on the Bitcoin network by simplifying the integration of new features.

The Impact of Taproot

Taproot’s three-pronged approach offers a multitude of benefits for Bitcoin users and the network as a whole:

• Increased Efficiency: Transactions become smaller and faster to verify, thanks to Schnorr Signatures. This translates to lower transaction fees and a more scalable network.
• Enhanced Privacy: By concealing the intricacies of complex transactions, Taproot makes it harder to analyze spending patterns on the blockchain, leading to greater user privacy.
• Expanded Functionality: Taproot opens doors for more sophisticated smart contracts on the Bitcoin network, potentially enabling new use cases in the future.

The Adoption of Taproot

To fully unlock the benefits of Taproot, wallet interoperability is essential. To achieve this, Taproot requires the ability to support a new address format, Bech32m. According to whentaproot, an open-source project tracking Bech32m adoption in Bitcoin software, the majority of Bitcoin projects now support Bech32m.

Conclusion

Taproot represents a significant milestone in the evolution of Bitcoin, unlocking new possibilities for smart contracts, privacy, and scalability. With its improved efficiency and flexibility, Taproot paves the way for a more robust and versatile Bitcoin network in the years to come.

Resources:

• The Schnorr Signature & Taproot Softfork Proposal
• Bitcoin Taproot -  A Technical Explanation 2024 - CoinCodeCap

Creating bitcoin transactions can feel like a daunting task. However, the bitcoin-js library stands out as an exceptional Node.js library designed for a variety of Bitcoin operations including building transactions. This open-source library empowers developers to interact with the Bitcoin blockchain through JavaScript/Typescript, making it a versatile tool for creating and manipulating transactions programmatically. In this guide, we’ll explore the process of building a simple transaction using this popular JavaScript library.

Important: This guide operates on the Testnet bitcoin network. This means that any coins and transactions carried out during this process hold no real-world value.

Prerequisites

1. NodeJS
2. A Bitcoin Core Node configured to run on testnet

Create an Unspent Transaction Output ( UTXO) to spend

A UTXO refers to the output of a transaction that has not been spent or used in a subsequent transaction. Creating a transaction in Bitcoin means that you are spending a previous transaction. To create a UTXO on Testnet, you need to create a wallet, address and send testnet funds to that address using a faucet

After creating this UTXO, store the following information in a secure .env file

privateKeyWIF = 'your_private_key_in_wallet_import_format'
previousTxid = 'transaction_id'
previousHex ='transaction_hex'

Create and Broadcast A Simple Transaction

1. Setting Up Your Environment:
   Start by installing bitcoinjs-lib in your project. You can use npm (Node Package Manager) for this:

npm install bitcoinjs-lib

In order to manage SECP256k1 keypairs, you also need to install the ecpair and tiny-secp256k1 modules.

ECPair stands for Elliptic Curve Pair. In Bitcoin, it's commonly used to represent an ECDSA (Elliptic Curve Digital Signature Algorithm) key pair. This library provides methods for creating, importing, and manipulating elliptic curve key pairs, which are essential for cryptographic operations such as digital signatures and public-key encryption.

tiny-secp256k1 is a lightweight library used by BitcoinJS for low-level elliptic curve operations, specifically on the secp256k1 curve. This includes key pair generation, signature generation and verification, public key recovery and others.

To install these libraries in your project, use the node package manager commands below.

npm install ecpair

npm install tiny-secp256k1

2. Import the libraries to your project:

const bitcoin = require('bitcoinjs-lib')
const ECPairFactory = require('ecpair').default;
const ecc = require('tiny-secp256k1');

3. Set the network and ECPair:

const ECPair = ECPairFactory(ecc);
const network = bitcoin.networks.testnet

4. Create a transaction

// create a simple transaction
async function createTransaction(
privateKeyWIF, 
previousTxid, 
receiverAddress, 
previousHex
) {

//  take the WIF-encoded private key (privateKeyWIF) and network information 
// and create a keyPair that we'll use for signing the transaction
    const keyPair = ECPair.fromWIF(privateKeyWIF, network);

// create a transaction builder and pass the network. The bitcoin-js 
// Psbt class is used to do this. 
    const txb = new bitcoin.Psbt({ network });
    
// while these are default version and locktime values, you can set 
// custom values depending on your transaction
    txb.setVersion(2);
    txb.setLocktime(0);

// add inputs: previous transaction Id, output index of the funding transaction
// and, since this is a non segwit input, we must also pass the full previous 
// transaction hex as a buffer 
    txb.addInput({
        hash: previousTxid,
        index: 0,
        nonWitnessUtxo: Buffer.from(previousHex, 'hex'),
    });

// add outputs as the buffer of receiver's address and the value with amount
// of satoshis you're sending.
    txb.addOutput({
        script: Buffer.from(receiverAddress, 'hex'),
        value: 20000,
    }); // Sending 0.0002 BTC

// sign with the generate keyPair and finalize the transansction 
    txb.signInput(0, keyPair);
    txb.finalizeAllInputs();

//  extract the transaction and get the raw hex serialization
    const tx = txb.extractTransaction();
    return tx.toHex();
}

// this calls and executes the function above and then prints 
// the transaction hex
createTransaction(privateKeyWIF, previousTxid, previousHex, myAddress)
    .then((transactionHex) => {
        console.log('Transaction Hex:', transactionHex);
    })
    .catch((error) => {
        console.error('Error:', error.message);
    });

Your transaction is now ready to be broadcasted to the Bitcoin network!

5. Broadcast a transaction

Broadcasting a transaction refers to the process of propagating a signed transaction to the network so that it can be included in the next block by miners. Broadcasting is essential for making a transaction visible to the decentralized network of nodes, allowing miners to verify and include it in the blockchain.

To broadcast a transaction on the Bitcoin Testnet, we will use the bitcoin-clicommand-line tool, which is part of the Bitcoin Core software. Ensure that your Bitcoin Core node is configured to run on the Testnet and that it’s fully synced with the Testnet blockchain.

With your bitcoin core node running, open your terminal and run the following command;

bitcoin-cli -testnet sendrawtransaction <transactionHex>

The transactionHex used above is what we obtained from step 4 of creating a transaction. If the transaction is successfully broadcasted, the command will return a transaction ID (TxID). You can also check the status of your transaction using various blockchain explorers for the Testnet.

Broadcasting a transaction is a essential part of the decentralized nature of the Bitcoin network, ensuring that all participants have visibility into the transactions occurring on the network and facilitating the creation of a consensus-driven, immutable ledger.

Conclusion

Building a transaction using bitcoinjs-lib provides a hands-on experience in understanding the intricacies of bitcoin transactions. As you explore further and experiment with different inputs, outputs, and transaction structures, you’ll discover the power and flexibility that this library offers.

Resources:

• GitHub - bitcoinjs/bitcoinjs-lib: A javascript Bitcoin library for node.js and browsers.
• Bitcoin Programming with BitcoinJS, Bitcoin Core and LND
• Building Your Own Encrypted Wallet: A Developer’s guide to playing in the mud.
• Bitcoin Basics: Programming with bitcoinjs-lib

The Bitcoin Lightning Network is a second-layer scaling solution built on top of the Bitcoin blockchain. It is designed to enable faster and cheaper transactions. Developing and testing Lightning Network applications can be challenging, but tools like Polar can simplify the process by providing a user-friendly environment. This article will guide you through the process of setting up a Bitcoin Lightning development environment on Regtest using Polar.

Prerequisites

1. Docker Server (Installation guide here)
2. Docker Compose (Installation guide here)

Installing Polar

Polar is a tool developed by Lightning Labs to create and manage Lightning Network nodes for development and testing purposes. To install Polar on Linux, follow these steps:

Download the Polar application package from here.

Because the Polar application is an AppImage package, we will also install the AppImageLauncher to ease the installation of our Polar package.

sudo add-apt-repository ppa:appimagelauncher-team/stable
sudo apt-get update
sudo apt-get install appimagelauncher

When the above is complete, double-click the “.AppImage ” package you just downloaded and that will launch your polar application.

Setting Up Lightning Nodes

When you run Polar, the following welcome screen will appear.

Click either the orange “Create a Lightning Network” button in the middle, or Create Network in the top right corner.

After clicking Create Network, the above screen will appear. You can specify how many of each node implementations your network will be composed of. For this guide, create a new Lightning Network with the following parameters:

Network Name = My Network
Number of Managed Nodes:
LND = 2
Core Lightning = 0
Eclair = 0
Bitcoin Core = 1

Note: You will always need at least one Bitcoin Core node!

After clicking the orange Create Network button, Polar will display this new screen.

Polar allows you to play with any version for any implementation, including those in beta by providing the Network Designer Tab on the far right in the above screenshot. You can add a node of any version by dragging and dropping it onto the canvas to add it to the network you created.

Initiate your local network by clicking the Start button located in the top right corner, highlighted in orange. Allow a few seconds for the nodes to initialize; you’ll know the process is complete when the indicator lights turn green. After this, select the “Alice” LND node to access the screen tabs below.

The details on this screen are mostly straightforward. Currently, the local regtest instance is only at Block Height = 1, resulting in both Alice’s Confirmed Balance and Unconfirmed Balance being 0 sats. To change this, navigate to the Actions tab for Alice, confirm that Deposit Funds is configured to 1,000,000 sats, and then click on Deposit.

Starting with 1,000,000 sats in test environments like our local regtest instance provides a reasonable amount of satoshis for testing various Bitcoin functionalities without needing to worry about small fractions constantly. It offers enough satoshis to facilitate transactions, create different spending scenarios, and observe their effects.

Polar’s Mining Simulation

To mine more blocks, click the backend1 node, in the actions tab. A mine button will be visible.

While Polar’s mining simulation might appear similar to real-world mining, it’s not generating real Bitcoin on the main Bitcoin network. Polar creates a regtest environment, which is a separate, simulated network for testing purposes. Regtest coins have no real-world value and cannot be transferred to the main Bitcoin network.

Create and Pay an Invoice

Having funded Alice’s on-chain wallet, the next step is to open a channel. Click on “Open Channel” -> “Outgoing,” choose Bob as the destination, keep the default Capacity at 250,000 sats, and then click the orange “Open Channel” button.

After successfully opening the channel, select the new green line connecting Alice and Bob’s LND nodes to view the channel details below.

Hover over the green dot on Alice’s node to reveal “Source,” and over the blue dot on Bob’s node to display “Destination.” This indicates that the side with a Source Balance of 246,530 sats is Alice’s, while the side with a Destination Balance of 0 sats belongs to Bob.

Since Bob currently has no Destination Balance, right-click on his node to open an Actions panel. Choose “Create Invoice,” accept the default Amount of 50,000 sats, and click the orange “Create Invoice” button. If done successfully, this action should generate the following screen.

Select “Copy & Close,” then right-click on Alice’s node and choose “Pay Invoice.” Paste the invoice copied into the Bolt 11 Invoice field and click the orange “Pay Invoice” button. Upon completion, the dashboards for Alice, Bob, and the channel will resemble the following:

Congratulations! You’ve made your first successful Lightning Network payment on regtest!

You may have noticed a “Launch” button below Terminal in the Actions tab of the different nodes. You can run also cli commands directly on each node you created by launching its terminal.

Polar makes setting up a Bitcoin-Lightning development environment on regtest a breeze. Its intuitive interface and powerful features provide a valuable sandbox for developers to test their applications and gain practical experience working with the Lightning Network.

I hope this article serves as a helpful guide for setting up your Bitcoin-Lightning development environment with Polar. Feel free to explore the additional resources and documentation available within the Lightning ecosystem to further your knowledge and development efforts.