闪电网络与微支付：电影订阅经济的比特币结算层

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title LightningContentSettlement
 * @notice 基于闪电网络HTLC的内容结算合约
 * 将链下支付通道的最终状态锚定到链上进行公证
 * 支持多创作者分账和自动版税分配
 */
contract LightningContentSettlement {
    address public platformOwner;
    uint256 public constant SETTLEMENT_WINDOW = 7200; // 2小时时间窗口

    struct ContentPayment {
        string contentId;       // 内容ID（如电影哈希）
        address creator;        // 创作者地址
        uint256 totalSats;      // 结算总金额（聪）
        uint256 viewCount;      // 有效观看次数
        uint256 timestamp;      // 结算时间戳
        bytes32 channelRoot;    // 通道状态树根哈希
    }

    struct RoyaltySplit {
        address recipient;
        uint256 basisPoints;    // 万分比，如1000 = 10%
    }

    mapping(bytes32 => ContentPayment) public settlements;
    mapping(address => uint256) public creatorBalances;
    mapping(string => RoyaltySplit[]) public contentRoyalties;

    event ContentSettled(
        bytes32 indexed settlementId,
        string contentId,
        address indexed creator,
        uint256 totalSats,
        uint256 viewCount
    );

    event CreatorWithdrawn(address indexed creator, uint256 amount);

    event RoyaltyDistributed(
        bytes32 indexed settlementId,
        address indexed recipient,
        uint256 amount
    );

    constructor() {
        platformOwner = msg.sender;
    }

    /**
     * @notice 设置内容版权分成比例
     * @param _contentId 内容标识符
     * @param _splits 分成接收方及比例数组
     */
    function setRoyaltySplits(
        string memory _contentId,
        RoyaltySplit[] memory _splits
    ) external {
        require(msg.sender == platformOwner, "Only platform");
        uint256 totalBasis = 0;
        for (uint256 i = 0; i < _splits.length; i++) {
            totalBasis += _splits[i].basisPoints;
            require(_splits[i].recipient != address(0), "Invalid recipient");
        }
        require(totalBasis <= 10000, "Basis points exceed 100%");
        delete contentRoyalties[_contentId];
        for (uint256 i = 0; i < _splits.length; i++) {
            contentRoyalties[_contentId].push(_splits[i]);
        }
    }

    /**
     * @notice 提交闪电网络通道的最终结算状态
     * 自动按版权分成比例分配收益
     */
    function submitSettlement(
        string memory _contentId,
        address _creator,
        uint256 _totalSats,
        uint256 _viewCount,
        bytes32 _channelRoot
    ) external {
        require(msg.sender == platformOwner, "Only platform can settle");
        bytes32 settlementId = keccak256(
            abi.encodePacked(_contentId, _creator, block.timestamp)
        );

        settlements[settlementId] = ContentPayment({
            contentId: _contentId,
            creator: _creator,
            totalSats: _totalSats,
            viewCount: _viewCount,
            timestamp: block.timestamp,
            channelRoot: _channelRoot
        });

        // 自动分配版税
        uint256 remaining = _totalSats;
        RoyaltySplit[] storage splits = contentRoyalties[_contentId];
        for (uint256 i = 0; i < splits.length; i++) {
            uint256 royaltyAmount = (_totalSats * splits[i].basisPoints) / 10000;
            if (royaltyAmount > 0) {
                creatorBalances[splits[i].recipient] += royaltyAmount;
                remaining -= royaltyAmount;
                emit RoyaltyDistributed(settlementId, splits[i].recipient, royaltyAmount);
            }
        }
        // 剩余归创作者
        if (remaining > 0) {
            creatorBalances[_creator] += remaining;
        }

        emit ContentSettled(settlementId, _contentId, _creator, _totalSats, _viewCount);
    }

    /**
     * @notice 创作者提取累积结算收益
     */
    function withdraw() external {
        uint256 amount = creatorBalances[msg.sender];
        require(amount > 0, "No balance to withdraw");
        creatorBalances[msg.sender] = 0;
        payable(msg.sender).transfer(amount);
        emit CreatorWithdrawn(msg.sender, amount);
    }
}

// Lightning Network Content Subscription Manager
// 闪电网络内容订阅管理器 - 客户端SDK

class LightningSubscriptionClient {
  constructor(lightningNodeUrl, walletPrivKey) {
    this.nodeUrl = lightningNodeUrl;
    this.privKey = walletPrivKey;
    this.channels = new Map();
    this.activeStreams = new Map();
    this.consumptionHistory = [];
  }

  /**
   * 向内容平台打开支付通道
   * @param {string} platformId - 平台节点公钥
   * @param {number} capacity - 通道容量（聪）
   * @param {number} reserve - 保留余额（聪）
   */
  async openContentChannel(platformId, capacity, reserve = 1000) {
    const channelId = `${platformId}-${Date.now()}`;
    this.channels.set(channelId, {
      platformId,
      capacity,
      localBalance: capacity - reserve,
      remoteBalance: reserve,
      status: 'open',
      htlcs: [],
      createdAt: Date.now()
    });
    console.log(`[LN] 通道已打开: ${channelId}, 容量: ${capacity} sats`);
    return channelId;
  }

  /**
   * 按秒支付流媒体内容消费
   * @param {string} channelId - 支付通道ID
   * @param {string} contentId - 内容哈希
   * @param {number} durationSec - 观看时长（秒）
   * @param {number} ratePerSec - 每秒费率（聪）
   * @returns {Promise<Object>} 支付证明
   */
  async payPerSecond(channelId, contentId, durationSec, ratePerSec) {
    const channel = this.channels.get(channelId);
    if (!channel || channel.status !== 'open') {
      throw new Error('通道未打开');
    }

    const totalCost = durationSec * ratePerSec;
    if (channel.localBalance < totalCost) {
      throw new Error('通道余额不足');
    }

    const preimage = crypto.randomBytes(32);
    const hashLock = crypto.createHash('sha256').update(preimage).digest('hex');

    const htlc = {
      hashLock,
      amount: totalCost,
      expiry: Math.floor(Date.now() / 1000) + 7200,
      contentId,
      durationSec,
      ratePerSec,
      timestamp: Date.now()
    };

    channel.htlcs.push(htlc);
    channel.localBalance -= totalCost;
    channel.remoteBalance += totalCost;

    this.activeStreams.set(contentId, {
      channelId,
      startTime: Date.now(),
      paidSeconds: durationSec,
      ratePerSec
    });

    this.consumptionHistory.push({
      contentId,
      amount: totalCost,
      durationSec,
      timestamp: new Date().toISOString()
    });

    return {
      paymentHash: hashLock,
      amount: totalCost,
      contentType: 'streaming_video',
      contentId,
      preimage: preimage.toString('hex')
    };
  }

  /**
   * 批量结算多个微支付
   * @param {string} channelId - 支付通道ID
   * @returns {Object} 结算证明
   */
  settleBatch(channelId) {
    const channel = this.channels.get(channelId);
    if (!channel) throw new Error('通道不存在');

    const totalPaid = channel.htlcs.reduce((sum, h) => sum + h.amount, 0);
    const totalDuration = channel.htlcs.reduce((sum, h) => sum + h.durationSec, 0);

    channel.status = 'settling';

    const settlementProof = {
      channelId,
      totalPayments: channel.htlcs.length,
      totalPaid,
      totalDurationSec: totalDuration,
      localBalanceAfter: channel.localBalance,
      remoteBalanceAfter: channel.remoteBalance,
      settlementTime: new Date().toISOString()
    };

    channel.htlcs = [];
    channel.status = 'open';

    return settlementProof;
  }

  /**
   * 获取消费统计
   * @param {string} contentId - 内容标识符
   */
  getContentConsumption(contentId) {
    const stream = this.activeStreams.get(contentId);
    if (!stream) return null;

    const elapsed = (Date.now() - stream.startTime) / 1000;
    return {
      contentId,
      watchedSeconds: elapsed,
      costSoFar: elapsed * stream.ratePerSec,
      ratePerSec: stream.ratePerSec
    };
  }

  /**
   * 获取全部历史消费记录
   */
  getConsumptionHistory() {
    return {
      totalTransactions: this.consumptionHistory.length,
      totalSpent: this.consumptionHistory.reduce((sum, h) => sum + h.amount, 0),
      totalDuration: this.consumptionHistory.reduce((sum, h) => sum + h.durationSec, 0),
      records: this.consumptionHistory
    };
  }

  /**
   * 关闭通道并提取余额
   * @param {string} channelId
   */
  closeChannel(channelId) {
    const channel = this.channels.get(channelId);
    if (!channel) throw new Error('通道不存在');

    const refund = channel.localBalance;
    channel.status = 'closed';

    return {
      channelId,
      refund,
      totalPaid: channel.htlcs.reduce((sum, h) => sum + h.amount, 0),
      closedAt: new Date().toISOString()
    };
  }
}

// 使用示例
const client = new LightningSubscriptionClient(
  'https://lnd.bcu.lat:8080',
  '02a1b2c3d4e5f6...'
);

(async () => {
  const channelId = await client.openContentChannel(
    'platform_node_pubkey',
    50000
  );

  const payment = await client.payPerSecond(
    channelId,
    'QmFilmHash123',
    3600,
    3
  );

  console.log('支付证明:', payment);
  console.log('消费统计:', client.getContentConsumption('QmFilmHash123'));

  const settlement = client.settleBatch(channelId);
  console.log('批量结算:', settlement);
})();

import hashlib
import os
import time
from typing import Dict, Optional, List

class LightningContentStream:
    """
    闪电网络微支付内容流管理器
    模拟一个按秒计费的流媒体支付通道
    支持多创作者分账和动态费率调整
    """

    def __init__(self, creator_address: str, rate_per_second: int):
        self.creator = creator_address
        self.rate = rate_per_second
        self.channel_open = False
        self.balance = 0
        self.viewed_seconds = 0
        self.payment_preimages: Dict[str, bytes] = {}
        self.royalty_splits: List[Dict] = []
        self.transaction_log: List[Dict] = []

    def set_royalty_splits(self, splits: List[Dict]) -> None:
        """设置版权分成比例，例如 [{'address': 'addr1', 'share': 0.7}, ...]"""
        total = sum(s['share'] for s in splits)
        if abs(total - 1.0) > 0.0001:
            raise ValueError("分成比例之和必须为1.0")
        self.royalty_splits = splits

    def open_channel(self, deposit: int) -> bool:
        """打开支付通道，存入保证金"""
        if deposit < self.rate * 60:
            return False
        self.balance = deposit
        self.channel_open = True
        self.viewed_seconds = 0
        self.transaction_log = []
        return True

    def stream_frame(self, frame_data: bytes) -> Optional[bytes]:
        """流式传输一帧内容，生成HTLC预像"""
        if not self.channel_open:
            return None

        frame_cost = self.rate // 24
        if self.balance < frame_cost:
            self.close_channel()
            return None

        preimage = os.urandom(32)
        hash_lock = hashlib.sha256(preimage).hexdigest()

        self.balance -= frame_cost
        self.viewed_seconds += 1/24
        self.payment_preimages[hash_lock] = preimage

        self.transaction_log.append({
            'timestamp': time.time(),
            'frame_cost': frame_cost,
            'hash_lock': hash_lock,
            'cumulative_seconds': self.viewed_seconds
        })

        return frame_data

    def get_watchtower_proof(self) -> Dict:
        """生成瞭望塔证明，用于通道状态公证"""
        return {
            "creator": self.creator,
            "viewed_seconds": round(self.viewed_seconds, 2),
            "remaining_balance": self.balance,
            "total_cost": self.rate * self.viewed_seconds,
            "preimage_count": len(self.payment_preimages),
            "transaction_count": len(self.transaction_log),
            "timestamp": int(time.time())
        }

    def close_channel(self) -> Dict:
        """关闭通道，返回最终结算状态并自动分配收益"""
        if not self.channel_open:
            return {"error": "Channel already closed"}

        total_cost = int(self.rate * self.viewed_seconds)

        # 计算各版权方的收益
        distribution = []
        if self.royalty_splits:
            for split in self.royalty_splits:
                share_amount = int(total_cost * split['share'])
                distribution.append({
                    'recipient': split['address'],
                    'amount': share_amount,
                    'share': split['share']
                })

        settlement = {
            "creator": self.creator,
            "total_paid": total_cost,
            "viewed_seconds": round(self.viewed_seconds, 2),
            "refund": self.balance,
            "distribution": distribution,
            "preimages": list(self.payment_preimages.values())[:5],
            "transactions": len(self.transaction_log)
        }

        self.channel_open = False
        self.balance = 0
        self.viewed_seconds = 0
        self.payment_preimages = {}
        self.transaction_log = []

        return settlement