Liquid Network¶

Overview¶

The Liquid Network is a federated Bitcoin sidechain that enables confidential transactions, asset issuance, and advanced script capabilities through Elements opcodes. Anya Core provides full integration with Liquid Network for enhanced privacy and functionality.

Features¶

• Confidential Transactions: Hide transaction amounts while maintaining verifiability
• Asset Issuance: Create and manage digital assets on Bitcoin
• Fast Settlement: 1-minute block times with federated consensus
• Advanced Scripts: Enhanced scripting capabilities beyond Bitcoin Script
• Two-Way Peg: Secure movement of Bitcoin between networks

Configuration¶

Basic Configuration¶

use anya_core::layer2::liquid::{LiquidConfig, LiquidClient};

let config = LiquidConfig {
    network: "mainnet".to_string(),
    rpc_url: "https://liquid.network/rpc".to_string(),
    confidential: true,
    timeout_ms: 30000,
    federation_pubkeys: vec![
        "02142b5513b2bb94c35310618b6e7c80b08c04b0e3c26ba7e1b306b7f3fecefbfb".to_string(),
        // ... additional federation keys
    ],
    required_signatures: 11,
    elementsd_path: "/usr/local/bin/elementsd".to_string(),
};

let client = LiquidClient::new(config);

Environment Variables¶

LIQUID_NETWORK=mainnet
LIQUID_RPC_URL=https://liquid.network/rpc
LIQUID_CONFIDENTIAL=true
LIQUID_TIMEOUT_MS=30000
LIQUID_ELEMENTSD_PATH=/usr/local/bin/elementsd

Usage Examples¶

Asset Management¶

use anya_core::layer2::{AssetParams, AssetTransfer};

// Create a new asset
let asset_params = AssetParams {
    asset_id: "new_asset".to_string(),
    name: "My Digital Asset".to_string(),
    symbol: "MDA".to_string(),
    precision: 8,
    total_supply: 1_000_000,
    description: "A sample digital asset".to_string(),
};

let result = client.create_asset(asset_params).await?;
println!("Asset created: {:?}", result);

Confidential Transactions¶

// Send confidential transaction
let transfer = AssetTransfer {
    from: "sender_address".to_string(),
    to: "receiver_address".to_string(),
    amount: 50000,
    asset_id: "L-BTC".to_string(),
    memo: Some("Confidential payment".to_string()),
};

let result = client.transfer_asset(transfer).await?;
println!("Confidential transfer: {:?}", result);

Peg Operations¶

// Peg-in Bitcoin to Liquid
let peg_in_result = client.peg_in(
    "bitcoin_txid".to_string(),
    "liquid_address".to_string(),
    100000, // satoshis
).await?;

// Peg-out Liquid Bitcoin back to Bitcoin
let peg_out_result = client.peg_out(
    "bitcoin_address".to_string(),
    100000, // satoshis
).await?;

API Reference¶

LiquidClient¶

Methods¶

• new(config: LiquidConfig) -> Self
• connect() -> Result<(), Layer2Error>
• disconnect() -> Result<(), Layer2Error>
• get_state() -> Result<ProtocolState, Layer2Error>
• create_asset(params: AssetParams) -> Result<TransferResult, Layer2Error>
• transfer_asset(transfer: AssetTransfer) -> Result<TransferResult, Layer2Error>
• verify_proof(proof: Proof) -> Result<VerificationResult, Layer2Error>
• validate_transaction(tx_id: String) -> Result<ValidationResult, Layer2Error>
• peg_in(bitcoin_txid: String, liquid_address: String, amount: u64) -> Result<TransferResult, Layer2Error>
• peg_out(bitcoin_address: String, amount: u64) -> Result<TransferResult, Layer2Error>

Configuration Options¶

Option	Type	Description	Default
network	String	Network type (mainnet/testnet)	"mainnet"
rpc_url	String	RPC endpoint URL	"https://liquid.network/rpc"
confidential	bool	Enable confidential transactions	true
timeout_ms	u64	Request timeout in milliseconds	30000
federation_pubkeys	Vec	Federation signer public keys	Default keys
required_signatures	u32	Minimum required signatures	11
elementsd_path	String	Path to Elements daemon	"/usr/local/bin/elementsd"

Security Considerations¶

Federation Trust Model¶

• Liquid uses a federated consensus model with trusted functionaries
• Transactions require 11 of 15 federation signatures
• Federation members include major Bitcoin companies and exchanges

Confidential Transactions¶

• Uses Pedersen commitments for amount hiding
• Range proofs ensure no inflation
• Confidential assets maintain privacy without sacrificing verifiability

Peg Security¶

• Two-way peg secured by federation multisig
• Emergency recovery mechanisms in case of federation failure
• Regular audits of peg wallet reserves

Best Practices¶

Development¶

1. Test on Testnet: Always test on Liquid testnet before mainnet deployment
2. Monitor Federation: Keep track of federation status and health
3. Handle Reorgs: Implement proper reorganization handling
4. Backup Keys: Secure backup of all private keys and seed phrases

Production¶

1. Monitor Connectivity: Implement health checks for RPC connectivity
2. Error Handling: Robust error handling for network failures
3. Rate Limiting: Respect RPC rate limits to avoid service disruption
4. Security Updates: Keep Elements daemon updated

Troubleshooting¶

Common Issues¶

Connection Failures¶

// Check network connectivity
match client.connect().await {
    Ok(_) => println!("Connected successfully"),
    Err(e) => println!("Connection failed: {}", e),
}

Asset Creation Errors¶

• Verify sufficient L-BTC for fees
• Check asset parameters are valid
• Ensure proper permissions for asset issuance

Peg Operation Issues¶

• Confirm Bitcoin transaction has sufficient confirmations
• Verify Liquid address format is correct
• Check federation is operational

Debugging¶

Enable debug logging:

RUST_LOG=anya_core::layer2::liquid=debug cargo run

Support Resources¶

• Liquid Network Documentation
• Elements Project
• Anya Core Issues

Examples¶

Complete Asset Workflow¶

use anya_core::layer2::liquid::{LiquidConfig, LiquidClient};
use anya_core::layer2::{AssetParams, AssetTransfer};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client
    let config = LiquidConfig::default();
    let mut client = LiquidClient::new(config);

    // Connect to network
    client.connect().await?;

    // Create asset
    let asset_params = AssetParams {
        asset_id: "company_shares".to_string(),
        name: "Company Shares".to_string(),
        symbol: "COMP".to_string(),
        precision: 0,
        total_supply: 1000,
        description: "Company equity shares".to_string(),
    };

    let asset_result = client.create_asset(asset_params).await?;
    println!("Asset created: {:?}", asset_result);

    // Transfer asset
    let transfer = AssetTransfer {
        from: "issuer_address".to_string(),
        to: "investor_address".to_string(),
        amount: 100,
        asset_id: "company_shares".to_string(),
        memo: Some("Initial allocation".to_string()),
    };

    let transfer_result = client.transfer_asset(transfer).await?;
    println!("Transfer completed: {:?}", transfer_result);

    Ok(())
}

Integration Notes¶

• Compatible with all Bitcoin wallets through two-way peg
• Supports atomic swaps with other Layer2 protocols
• Integration with Lightning Network for instant payments
• Compatible with Bitcoin Script and enhanced Elements opcodes