虚拟币用到的非常哇塞的技术(闪电网络)解读_闪电网络解决什么问题了-CSDN博客

本文链接：https://blog.csdn.net/zhangzhechun_03/article/details/147779306

python编程示例系列
 python编程示例系列二
 python的Web神器Streamlit
如何应聘高薪职位
 C#视觉应用开发问题系列
 c#串口应用开发问题系列
 microPython Python最小内核源码解析
 NI-motion运动控制c语言示例代码解析
在这里插入图片描述 # 闪电网络(Lightning Network)详解

用途

闪电网络是比特币等区块链的第二层扩展解决方案，主要解决以下问题：

扩展性问题：提高交易吞吐量，突破区块链主网的交易速度限制
微支付可行性：实现小额交易而不产生高额矿工费
即时确认：交易几乎实时确认，无需等待区块确认
降低费用：减少链上交易费用

原理

闪电网络的核心原理包括：

支付通道：两方之间建立的链下通道，允许多次交易而只在通道开启和关闭时与区块链交互
多重签名：使用多重签名钱包来锁定资金，确保通道安全
哈希时间锁定合约(HTLC)：确保支付路由安全，即使通过多个中间节点也能安全完成交易
路由：通过网络中的多个支付通道路由交易，无需直接连接

实现代码示例

以下是一个简化的闪电网络节点实现示例，包含基本功能：

import hashlib
import time
import random
import json
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

class LightningNode:
    """闪电网络节点类，实现基本的闪电网络功能"""
    
    def __init__(self, node_id):
        """
        初始化闪电网络节点
        参数:
            node_id: 节点唯一标识符
        """
        self.node_id = node_id
        # 生成RSA密钥对用于签名和验证
        self.private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=2048
        )
        self.public_key = self.private_key.public_key()
        # 存储与其他节点的支付通道
        self.channels = {}
        # 存储正在处理的HTLC
        self.pending_htlcs = {}
        # 存储路由表信息
        self.routing_table = {}
        # 节点余额
        self.balance = 0
        
    def create_channel(self, peer_id, peer_public_key, local_amount):
        """
        创建与对等节点的支付通道
        参数:
            peer_id: 对等节点ID
            peer_public_key: 对等节点公钥
            local_amount: 本地提交到通道的金额
        返回:
            channel_id: 通道ID
        """
        if local_amount > self.balance:
            raise ValueError("余额不足以创建通道")
            
        # 生成通道ID（实际中应该是多重签名交易的txid）
        channel_id = hashlib.sha256(f"{self.node_id}:{peer_id}:{time.time()}".encode()).hexdigest()
        
        # 创建通道状态
        channel = {
            "peer_id": peer_id,
            "peer_public_key": peer_public_key,
            "local_balance": local_amount,
            "remote_balance": 0,  # 初始时对方余额为0，等待对方注资
            "status": "pending",  # 等待对方确认
            "htlcs": []
        }
        
        # 从余额中扣除资金
        self.balance -= local_amount
        
        # 存储通道信息
        self.channels[channel_id] = channel
        
        print(f"通道 {channel_id} 创建成功，等待对方确认")
        return channel_id
    
    def accept_channel(self, channel_id, peer_id, peer_amount):
        """
        接受来自对等节点的通道创建请求
        参数:
            channel_id: 通道ID
            peer_id: 对等节点ID
            peer_amount: 对等节点提交的金额
        """
        if channel_id not in self.channels:
            raise ValueError("通道不存在")
            
        channel = self.channels[channel_id]
        if channel["status"] != "pending":
            raise ValueError("通道状态错误")
            
        # 更新通道状态
        channel["remote_balance"] = peer_amount
        channel["status"] = "open"
        
        print(f"通道 {channel_id} 已确认并开启")
    
    def create_payment_hash(self, amount, memo=""):
        """
        创建支付哈希和预映像
        参数:
            amount: 支付金额
            memo: 支付备注
        返回:
            payment_hash: 支付哈希
            payment_preimage: 支付原像
        """
        # 生成随机预映像
        payment_preimage = str(random.getrandbits(256))
        # 计算哈希
        payment_hash = hashlib.sha256(payment_preimage.encode()).hexdigest()
        
        return payment_hash, payment_preimage
    
    def create_invoice(self, amount, memo="", expiry=3600):
        """
        创建支付发票
        参数:
            amount: 支付金额
            memo: 支付备注
            expiry: 过期时间（秒）
        返回:
            invoice: 支付发票
        """
        payment_hash, payment_preimage = self.create_payment_hash(amount, memo)
        
        # 创建发票
        invoice = {
            "node_id": self.node_id,
            "payment_hash": payment_hash,
            "amount": amount,
            "memo": memo,
            "timestamp": int(time.time()),
            "expiry": expiry
        }
        
        # 签名发票
        invoice_data = json.dumps(invoice, sort_keys=True).encode()
        signature = self.private_key.sign(
            invoice_data,
            padding.PSS(
                mgf=padding.MGF1(hashes.SHA256()),
                salt_length=padding.PSS.MAX_LENGTH
            ),
            hashes.SHA256()
        )
        
        invoice["signature"] = signature.hex()
        
        # 存储预映像以便后续验证
        self.pending_htlcs[payment_hash] = {
            "preimage": payment_preimage,
            "amount": amount,
            "status": "pending"
        }
        
        return invoice
    
    def add_htlc(self, channel_id, payment_hash, amount, cltv_expiry):
        """
        添加HTLC到通道
        参数:
            channel_id: 通道ID
            payment_hash: 支付哈希
            amount: 金额
            cltv_expiry: CLTV过期块高度
        """
        if channel_id not in self.channels:
            raise ValueError("通道不存在")
            
        channel = self.channels[channel_id]
        if channel["status"] != "open":
            raise ValueError("通道未开启")
            
        if channel["local_balance"] < amount:
            raise ValueError("通道余额不足")
        
        # 创建HTLC
        htlc = {
            "payment_hash": payment_hash,
            "amount": amount,
            "cltv_expiry": cltv_expiry,
            "status": "pending"
        }
        
        # 更新通道余额
        channel["local_balance"] -= amount
        channel["htlcs"].append(htlc)
        
        print(f"已添加HTLC到通道 {channel_id}，金额: {amount}，哈希: {payment_hash}")
    
    def fulfill_htlc(self, channel_id, payment_hash, payment_preimage):
        """
        使用支付原像兑现HTLC
        参数:
            channel_id: 通道ID
            payment_hash: 支付哈希
            payment_preimage: 支付原像
        """
        if channel_id not in self.channels:
            raise ValueError("通道不存在")
            
        channel = self.channels[channel_id]
        
        # 查找HTLC
        htlc_found = False
        for htlc in channel["htlcs"]:
            if htlc["payment_hash"] == payment_hash and htlc["status"] == "pending":
                htlc_found = True
                
                # 验证原像
                calculated_hash = hashlib.sha256(payment_preimage.encode()).hexdigest()
                if calculated_hash != payment_hash:
                    raise ValueError("支付原像无效")
                
                # 更新HTLC状态
                htlc["status"] = "fulfilled"
                
                # 更新通道余额
                channel["remote_balance"] += htlc["amount"]
                
                print(f"已兑现HTLC，通道: {channel_id}，金额: {htlc['amount']}，哈希: {payment_hash}")
                break
        
        if not htlc_found:
            raise ValueError("找不到匹配的HTLC")
    
    def close_channel(self, channel_id, cooperative=True):
        """
        关闭支付通道
        参数:
            channel_id: 通道ID
            cooperative: 是否是协作关闭
        """
        if channel_id not in self.channels:
            raise ValueError("通道不存在")
            
        channel = self.channels[channel_id]
        if channel["status"] != "open":
            raise ValueError("通道未开启")
        
        # 检查是否有未解决的HTLC
        pending_htlcs = [htlc for htlc in channel["htlcs"] if htlc["status"] == "pending"]
        if pending_htlcs and cooperative:
            raise ValueError("通道有未解决的HTLC，无法协作关闭")
        
        # 将通道余额返回到钱包
        self.balance += channel["local_balance"]
        
        # 更新通道状态
        channel["status"] = "closed"
        
        print(f"通道 {channel_id} 已关闭，返还余额: {channel['local_balance']}")
    
    def find_route(self, target_node_id, amount):
        """
        查找到目标节点的支付路径
        参数:
            target_node_id: 目标节点ID
            amount: 支付金额
        返回:
            route: 支付路径
        """
        # 简化的路由查找算法，实际中应使用更复杂的图算法
        if target_node_id in self.routing_table:
            direct_route = self.routing_table[target_node_id]
            if direct_route["capacity"] >= amount:
                return [direct_route]
        
        # 寻找中间路径
        # 这里仅作为示例，实际中应使用如Dijkstra或A*等算法
        routes = []
        for node, route_info in self.routing_table.items():
            if node != target_node_id and target_node_id in self.routing_table.get(node, {}).get("connections", {}):
                next_hop = self.routing_table[node]
                final_hop = self.routing_table[node]["connections"][target_node_id]
                
                if next_hop["capacity"] >= amount and final_hop["capacity"] >= amount:
                    routes.append([next_hop, final_hop])
        
        if routes:
            # 选择费用最低的路径
            return min(routes, key=lambda r: sum(hop.get("fee", 0) for hop in r))
        
        return None
    
    def send_payment(self, invoice, route=None):
        """
        发送支付
        参数:
            invoice: 支付发票
            route: 可选的预定义路由
        """
        # 解析发票
        payment_hash = invoice["payment_hash"]
        amount = invoice["amount"]
        target_node_id = invoice["node_id"]
        
        # 如果没有提供路由，尝试查找路由
        if not route:
            route = self.find_route(target_node_id, amount)
            if not route:
                raise ValueError(f"无法找到到节点 {target_node_id} 的路由")
        
        # 计算超时时间（实际中应基于路由长度和区块高度）
        current_time = int(time.time())
        cltv_expiry = current_time + 144  # 约24小时
        
        # 创建HTLC并沿路径发送
        # 注意：这是简化实现，实际中涉及到更复杂的协议交互
        first_hop = route[0]
        channel_id = first_hop["channel_id"]
        
        try:
            self.add_htlc(channel_id, payment_hash, amount, cltv_expiry)
            print(f"支付已发送，金额: {amount}，目标节点: {target_node_id}")
            return True
        except Exception as e:
            print(f"支付失败: {str(e)}")
            return False
    
    def receive_payment(self, payment_hash, payment_preimage):
        """
        接收支付
        参数:
            payment_hash: 支付哈希
            payment_preimage: 支付原像
        """
        if payment_hash not in self.pending_htlcs:
            raise ValueError("未找到匹配的支付哈希")
        
        htlc_info = self.pending_htlcs[payment_hash]
        
        # 验证原像
        calculated_hash = hashlib.sha256(payment_preimage.encode()).hexdigest()
        if calculated_hash != payment_hash:
            raise ValueError("支付原像无效")
        
        # 更新状态
        htlc_info["status"] = "fulfilled"
        
        # 添加到余额
        self.balance += htlc_info["amount"]
        
        print(f"支付已接收，金额: {htlc_info['amount']}，哈希: {payment_hash}")
        return True

# 演示如何使用闪电网络节点
def demo():
    # 创建两个节点
    alice = LightningNode("alice")
    bob = LightningNode("bob")
    
    # 给节点一些初始余额（在实际中，这应该是通过链上交易获得的）
    alice.balance = 1000
    bob.balance = 500
    
    print("初始余额:")
    print(f"Alice: {alice.balance}")
    print(f"Bob: {bob.balance}")
    
    # 创建通道
    channel_id = alice.create_channel("bob", bob.public_key, 100)
    bob.accept_channel(channel_id, "alice", 50)
    
    print("\n通道创建后:")
    print(f"Alice 通道余额: {alice.channels[channel_id]['local_balance']}")
    print(f"Bob 通道余额: {bob.channels[channel_id]['remote_balance']}")
    
    # 创建支付
    invoice = bob.create_invoice(10, "测试支付")
    print(f"\n创建发票: {invoice['payment_hash']}")
    
    # Alice 发送支付
    # 简化处理，实际中需要更复杂的路由
    alice.routing_table["bob"] = {
        "channel_id": channel_id,
        "capacity": 100,
        "fee": 1
    }
    
    alice.send_payment(invoice)
    
    # Bob 兑现HTLC
    payment_hash = invoice["payment_hash"]
    payment_preimage = bob.pending_htlcs[payment_hash]["preimage"]
    bob.fulfill_htlc(channel_id, payment_hash, payment_preimage)
    
    print("\n支付后通道状态:")
    print(f"Alice 通道余额: {alice.channels[channel_id]['local_balance']}")
    print(f"Bob 通道余额: {bob.channels[channel_id]['remote_balance']}")
    
    # 关闭通道
    alice.close_channel(channel_id)
    
    print("\n关闭通道后:")
    print(f"Alice 余额: {alice.balance}")
    print(f"Bob 余额: {bob.balance}")

if __name__ == "__main__":
    demo()