Liquid Network Solutions (Bitcoin Sidechain)
Liquid Network is a federated sidechain over Bitcoin, developed by Blockstream. Unlike Lightning Network (payment channels), Liquid is a full blockchain with its own blocks (~1 minute), native L-BTC asset and ability to issue custom assets (tokens, stablecoins, security tokens). Confidential Transactions — built-in privacy: amounts and asset types hidden from outsiders.
Liquid is relevant for: trading platforms needing fast Bitcoin-denominated settlement, issuing tokenized securities with privacy requirements, exchangers with quick bitcoin settlement. Niche technology, but without alternatives in its niche.
Liquid Network architecture
Federation model
Liquid doesn't use proof-of-work and has no public mining. Blocks created by functionaries — federants, which are major exchanges (Bitfinex, Kraken, OKX, etc.) and service providers. Consensus via threshold multisig: 2/3 functionary signatures needed per block.
Not trustless like Bitcoin mainnet — you trust the federation. Trade-off: get fast transactions, 2-block finality (~2 minutes), low fees, and Confidential Transactions.
Peg-in / Peg-out — BTC ↔ L-BTC exchange mechanism:
- Peg-in: send BTC to federated peg address → receive L-BTC in ~100 Bitcoin blocks (~16 hours) for security
- Peg-out: burn L-BTC via federation → receive BTC (~2 hours)
Confidential Transactions
Liquid's key feature, why financial institutions use it. Transfer amounts hidden via Pedersen Commitments, asset type hidden via asset surjection proofs. Only sender and recipient know real numbers.
Regular Bitcoin UTXO: value = 1.5 BTC (visible to all)
Liquid Confidential TX: value = [commitment] (only for transaction participants)
Verification of correctness (no money creation) possible mathematically without revealing amounts — via homomorphic commitment properties.
Development on Liquid: tooling
Elements Core and Liquid daemon
Liquid is a fork of Elements (Blockstream open-source project). For development, need elementsd (Elements Core daemon) in regtest mode — local node without mainnet connection.
# Run Elements in regtest for development
elementsd \
-chain=elementsregtest \
-validatepegin=0 \
-initialfreecoins=2100000000000000 \
-rpcuser=user \
-rpcpassword=password \
-rpcport=18884 \
-daemon
libwally-core: low-level transaction work
Blockstream developed libwally-core — C library for creating Bitcoin and Liquid transactions. Bindings available for Python, JavaScript, Java.
import wallycore as wally
# Initialize libwally
wally.init(0)
# Generate master key from seed
seed = bytes.fromhex('your_seed_hex')
master_key = wally.bip32_key_from_seed(seed, wally.BIP32_VER_MAIN_PRIVATE, 0)
# Derive keys for Liquid addresses
child_key = wally.bip32_key_from_parent(master_key, 0, wally.BIP32_FLAG_KEY_PRIVATE)
# Confidential address (with blinding key)
pub_key = wally.bip32_key_get_pub_key(child_key)
blinding_key = wally.asset_blinding_key_from_seed(seed)
conf_address = wally.confidential_addr_from_addr_segwit(
wally.bech32_from_bytes('ex', pub_key, 0), # ex = liquid mainnet, ert = regtest
'lq', # confidential address prefix
blinding_key[:32]
)
GDK (Green Development Kit)
Higher-level SDK from Blockstream, used in Green wallet. Suitable for wallet applications:
import greenlight from '@blockstream/greenlight-sdk'
// Initialize GDK session for Liquid
const session = greenlight.create_session()
await session.connect({ name: 'liquid' })
// Create wallet
const mnemonic = greenlight.generate_mnemonic()
await session.register_user({
mnemonic,
hw_device: {},
})
// Get address for receiving L-BTC
const addressDetails = await session.get_receive_address({
subaccount: 0,
address_type: 'p2wsh', // native segwit
is_internal: false,
})
console.log('Confidential address:', addressDetails.address)
console.log('Blinding key:', addressDetails.blinding_key)
Issuing Liquid Assets
Liquid allows issuing custom assets — like ERC-20 but with native privacy. Each asset identified by 32-byte asset ID (hash of issuance transaction).
Issuance via Elements RPC
# Via bitcoind-compatible RPC interface elementsd
import requests
def rpc_call(method, params):
response = requests.post(
'http://localhost:18884',
json={'method': method, 'params': params},
auth=('user', 'password')
)
return response.json()['result']
# Issue new asset
# amount: quantity in satoshi-equivalent (8 decimals)
# reissuancetoken_amount: reissuance tokens to issue (for future emissions)
issuance = rpc_call('issueasset', [
1000000, # 10.00000000 assets
1, # 1 reissuance token
False # not blind issuance (for demo)
])
asset_id = issuance['asset']
token_id = issuance['token']
print(f"Asset ID: {asset_id}")
print(f"Reissuance token: {token_id}")
Asset Registry
For other users to see your asset name and ticker in wallets — register in Liquid Asset Registry:
curl -X POST https://assets.blockstream.info/ \
-H "Content-Type: application/json" \
-d '{
"asset_id": "YOUR_ASSET_ID",
"contract": {
"name": "My Security Token",
"ticker": "MST",
"precision": 8,
"issuer_pubkey": "YOUR_ISSUER_PUBKEY",
"version": 0,
"entity": {
"domain": "yourcompany.com"
}
}
}'
Domain verification via DNS TXT record — standard procedure.
Confidential Assets: token privacy
By default, issued assets aren't confidential — asset type visible in transaction. For financial instruments need full confidentiality: neither asset type nor amount visible to outsiders.
Confidential issuance requires blind at issuance:
# Blind issuance - hides asset type and amount
issuance = rpc_call('issueasset', [
1000000, # quantity
1, # reissuance tokens
True # blind = True
])
# Now asset type hidden in transaction via asset surjection proof
For transferring assets between confidential addresses — transactions automatically blind if both addresses confidential.
Atomic Swaps on Liquid
Liquid supports atomic swaps between different assets without intermediary — via HTLC (Hash Time Locked Contracts) or via Submarine Swaps with LN.
Practical use case: DEX on Liquid for tokenized security exchange without custody. Both parties sign transaction that atomically swaps assets — either both get or neither does:
# Build atomic swap transaction
# Alice: wants to swap 100 USDT-Liquid for 0.001 L-BTC
# Bob: wants to swap 0.001 L-BTC for 100 USDT-Liquid
# 1. Alice creates partial PSBT (Partially Signed Bitcoin Transaction)
alice_psbt = rpc_call('walletcreatefundedpsbt', [
[{'txid': alice_utxo_txid, 'vout': alice_utxo_vout}], # inputs (USDT)
[{bob_address: 100_00000000, 'asset': USDT_ASSET_ID}], # outputs (L-BTC to Alice)
0,
{'add_inputs': False}
])
# 2. Bob adds his inputs (L-BTC) and outputs (USDT to Bob)
# 3. Both sign → broadcast
Exchange integration: Liquid as settlement layer
Exchanges use Liquid for accelerating inter-platform settlement. L-BTC transaction settles in ~2 blocks (~2 minutes) vs 6 blocks Bitcoin (~60 minutes) with comparable security guarantees.
Schema for trading platform:
- Traders deposit L-BTC (or pegged-in BTC)
- Off-chain matching engine
- Settlement via Liquid transactions — fast and cheap
- Withdrawal via peg-out if needed
Liquid integration development: from 2 weeks (basic asset issuance/acceptance) to 2-3 months (full DEX with confidential atomic swaps, asset registry, blockchain explorer for custom assets).