虚拟币用到的非常哇塞的技术(深度区块链分析)解读-CSDN博客

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

python编程示例系列
 python编程示例系列二
 python的Web神器Streamlit
如何应聘高薪职位
 C#视觉应用开发问题系列
 c#串口应用开发问题系列
 microPython Python最小内核源码解析
 NI-motion运动控制c语言示例代码解析
在这里插入图片描述 # 深度区块链分析技术详解

一、用途与原理

深度区块链分析是一种用于追踪、分析和理解区块链上交易行为的技术。在虚拟货币领域，这项技术有着广泛的应用。

主要用途：

交易追踪：追踪特定地址的资金流向，建立资金流动图谱
身份关联：通过交易模式识别关联地址，推断可能属于同一实体
异常检测：识别可疑交易模式，发现潜在的非法活动
市场分析：分析大额交易和鲸鱼行为，预测市场趋势
风险评估：为交易所、金融机构提供地址风险评分

基本原理：

深度区块链分析结合了数据抓取、图数据库技术和机器学习算法，通过以下步骤实现：

从区块链网络获取交易数据
构建地址和交易的关系图
应用聚类算法识别地址簇
利用启发式规则和机器学习模型分析交易模式
生成可视化结果和分析报告

二、实现代码示例

以下是一个基于Python的深度区块链分析工具实现示例，主要针对比特币区块链：

import requests
import networkx as nx
import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime
import time
from sklearn.cluster import DBSCAN
import numpy as np

class BlockchainAnalyzer:
    def __init__(self):
        # 初始化区块链分析器
        self.api_base_url = "https://blockchain.info/"  # 使用公共API
        self.graph = nx.DiGraph()  # 创建有向图用于表示交易网络
        self.address_features = {}  # 存储地址特征
        self.clustered_addresses = {}  # 存储聚类结果
        
    def fetch_address_info(self, address):
        """
        获取特定比特币地址的交易信息
        
        参数:
            address: 比特币地址
        返回:
            地址的交易数据
        """
        try:
            # 通过API获取地址信息
            url = f"{self.api_base_url}rawaddr/{address}"
            response = requests.get(url)
            if response.status_code == 200:
                return response.json()
            else:
                print(f"获取地址信息失败: {response.status_code}")
                return None
        except Exception as e:
            print(f"获取地址信息时出错: {e}")
            return None
    
    def fetch_transaction_info(self, tx_hash):
        """
        获取特定交易的详细信息
        
        参数:
            tx_hash: 交易哈希
        返回:
            交易详细数据
        """
        try:
            # 通过API获取交易信息
            url = f"{self.api_base_url}rawtx/{tx_hash}"
            response = requests.get(url)
            if response.status_code == 200:
                return response.json()
            else:
                print(f"获取交易信息失败: {response.status_code}")
                return None
        except Exception as e:
            print(f"获取交易信息时出错: {e}")
            return None
    
    def build_transaction_graph(self, seed_address, depth=2):
        """
        构建以种子地址为起点的交易网络图
        
        参数:
            seed_address: 起始地址
            depth: 追踪深度，默认为2
        """
        # 待处理的地址队列
        addresses_to_process = [(seed_address, 0)]
        processed_addresses = set()
        processed_txs = set()
        
        # 广度优先搜索构建交易图
        while addresses_to_process:
            current_address, current_depth = addresses_to_process.pop(0)
            
            # 如果已达到最大深度或地址已处理，则跳过
            if current_depth > depth or current_address in processed_addresses:
                continue
                
            processed_addresses.add(current_address)
            print(f"处理地址: {current_address}, 深度: {current_depth}")
            
            # 获取地址信息
            address_data = self.fetch_address_info(current_address)
            if not address_data:
                continue
                
            # 提取地址特征
            self.extract_address_features(current_address, address_data)
            
            # 处理地址的交易
            for tx in address_data.get('txs', []):
                tx_hash = tx['hash']
                
                if tx_hash in processed_txs:
                    continue
                    
                processed_txs.add(tx_hash)
                
                # 处理交易输入
                for tx_input in tx.get('inputs', []):
                    if 'prev_out' in tx_input and 'addr' in tx_input['prev_out']:
                        input_address = tx_input['prev_out']['addr']
                        input_value = tx_input['prev_out']['value'] / 100000000  # 转换为BTC
                        
                        # 添加交易边到图中
                        self.graph.add_edge(input_address, current_address, 
                                           tx_hash=tx_hash, 
                                           value=input_value, 
                                           timestamp=tx['time'])
                        
                        # 如果深度未达到最大，将新地址加入待处理队列
                        if current_depth < depth and input_address not in processed_addresses:
                            addresses_to_process.append((input_address, current_depth + 1))
                
                # 处理交易输出
                for tx_output in tx.get('out', []):
                    if 'addr' in tx_output:
                        output_address = tx_output['addr']
                        output_value = tx_output['value'] / 100000000  # 转换为BTC
                        
                        # 添加交易边到图中
                        self.graph.add_edge(current_address, output_address, 
                                           tx_hash=tx_hash, 
                                           value=output_value, 
                                           timestamp=tx['time'])
                        
                        # 如果深度未达到最大，将新地址加入待处理队列
                        if current_depth < depth and output_address not in processed_addresses:
                            addresses_to_process.append((output_address, current_depth + 1))
            
            # 避免API请求过于频繁
            time.sleep(1)
    
    def extract_address_features(self, address, address_data):
        """
        从地址数据中提取特征
        
        参数:
            address: 比特币地址
            address_data: 地址的交易数据
        """
        # 提取基本特征
        features = {
            'total_received': address_data.get('total_received', 0) / 100000000,
            'total_sent': address_data.get('total_sent', 0) / 100000000,
            'final_balance': address_data.get('final_balance', 0) / 100000000,
            'n_tx': address_data.get('n_tx', 0)
        }
        
        # 计算高级特征
        txs = address_data.get('txs', [])
        if txs:
            # 交易时间间隔
            timestamps = sorted([tx['time'] for tx in txs])
            if len(timestamps) > 1:
                time_diffs = [timestamps[i+1] - timestamps[i] for i in range(len(timestamps)-1)]
                features['avg_time_between_txs'] = sum(time_diffs) / len(time_diffs)
                features['min_time_between_txs'] = min(time_diffs)
                features['max_time_between_txs'] = max(time_diffs)
            
            # 交易金额统计
            values = []
            for tx in txs:
                for output in tx.get('out', []):
                    if 'value' in output:
                        values.append(output['value'] / 100000000)
            
            if values:
                features['avg_tx_value'] = sum(values) / len(values)
                features['min_tx_value'] = min(values)
                features['max_tx_value'] = max(values)
                features['std_tx_value'] = np.std(values)
        
        self.address_features[address] = features
    
    def cluster_addresses(self, eps=0.5, min_samples=5):
        """
        使用DBSCAN算法对地址进行聚类
        
        参数:
            eps: DBSCAN的邻域半径参数
            min_samples: DBSCAN的最小样本数参数
        """
        # 准备特征矩阵
        addresses = list(self.address_features.keys())
        feature_names = ['total_received', 'total_sent', 'final_balance', 'n_tx']
        
        # 确保所有地址都有这些特征
        feature_matrix = []
        for addr in addresses:
            features = self.address_features[addr]
            feature_vector = [features.get(f, 0) for f in feature_names]
            feature_matrix.append(feature_vector)
        
        # 特征标准化
        feature_matrix = np.array(feature_matrix)
        feature_matrix = (feature_matrix - feature_matrix.mean(axis=0)) / feature_matrix.std(axis=0)
        
        # 应用DBSCAN聚类
        clustering = DBSCAN(eps=eps, min_samples=min_samples).fit(feature_matrix)
        labels = clustering.labels_
        
        # 整理聚类结果
        for i, addr in enumerate(addresses):
            cluster_id = labels[i]
            if cluster_id not in self.clustered_addresses:
                self.clustered_addresses[cluster_id] = []
            self.clustered_addresses[cluster_id].append(addr)
        
        # 输出聚类结果
        print(f"识别出 {len(self.clustered_addresses)} 个地址簇")
        for cluster_id, addrs in self.clustered_addresses.items():
            if cluster_id != -1:  # -1表示噪声点
                print(f"簇 {cluster_id}: {len(addrs)} 个地址")
    
    def detect_anomalies(self):
        """
        检测异常交易模式
        
        返回:
            异常交易列表
        """
        anomalies = []
        
        # 计算每条边的特征
        for u, v, data in self.graph.edges(data=True):
            # 大额交易检测
            if data.get('value', 0) > 10:  # 超过10 BTC的交易
                anomalies.append({
                    'type': 'large_transaction',
                    'from': u,
                    'to': v,
                    'tx_hash': data.get('tx_hash'),
                    'value': data.get('value'),
                    'timestamp': data.get('timestamp')
                })
            
            # 检测快速转移模式
            out_edges = list(self.graph.out_edges(v, data=True))
            if len(out_edges) == 1:
                next_edge = out_edges[0]
                curr_time = data.get('timestamp', 0)
                next_time = next_edge[2].get('timestamp', 0)
                
                # 如果在短时间内（1小时内）转出接近相同金额
                if 0 < next_time - curr_time < 3600 and abs(next_edge[2].get('value', 0) - data.get('value', 0)) < 0.1 * data.get('value', 0):
                    anomalies.append({
                        'type': 'quick_transfer',
                        'path': [u, v, next_edge[1]],
                        'value_in': data.get('value'),
                        'value_out': next_edge[2].get('value'),
                        'time_diff': next_time - curr_time
                    })
        
        return anomalies
    
    def visualize_transaction_graph(self, output_file="transaction_graph.png"):
        """
        可视化交易网络图
        
        参数:
            output_file: 输出图像文件名
        """
        plt.figure(figsize=(12, 10))
        
        # 使用不同颜色表示不同簇
        colors = {}
        for cluster_id, addrs in self.clustered_addresses.items():
            for addr in addrs:
                colors[addr] = cluster_id
        
        # 设置节点颜色
        node_colors = [colors.get(node, -1) for node in self.graph.nodes()]
        
        # 设置边的宽度根据交易金额
        edge_widths = [data.get('value', 1) * 0.1 + 0.1 for _, _, data in self.graph.edges(data=True)]
        
        # 绘制网络图
        pos = nx.spring_layout(self.graph)
        nx.draw_networkx(
            self.graph, 
            pos, 
            with_labels=False, 
            node_size=50, 
            node_color=node_colors, 
            width=edge_widths, 
            edge_color='gray', 
            arrows=True,
            cmap=plt.cm.jet
        )
        
        plt.title("比特币交易网络图")
        plt.axis('off')
        plt.savefig(output_file, dpi=300, bbox_inches='tight')
        plt.close()
        
        print(f"交易网络图已保存到 {output_file}")
    
    def generate_report(self):
        """
        生成分析报告
        
        返回:
            分析报告字典
        """
        report = {
            'graph_stats': {
                'nodes': self.graph.number_of_nodes(),
                'edges': self.graph.number_of_edges(),
                'clusters': len([k for k in self.clustered_addresses.keys() if k != -1])
            },
            'anomalies': self.detect_anomalies(),
            'clusters': {k: len(v) for k, v in self.clustered_addresses.items() if k != -1},
            'high_value_addresses': []
        }
        
        # 找出高价值地址
        for addr, features in self.address_features.items():
            if features.get('final_balance', 0) > 1:  # 余额超过1 BTC
                report['high_value_addresses'].append({
                    'address': addr,
                    'balance': features.get('final_balance'),
                    'total_received': features.get('total_received'),
                    'transaction_count': features.get('n_tx')
                })
        
        # 按余额排序
        report['high_value_addresses'].sort(key=lambda x: x['balance'], reverse=True)
        
        return report


# 使用示例
if __name__ == "__main__":
    # 创建分析器实例
    analyzer = BlockchainAnalyzer()
    
    # 设置起始地址（这里使用一个示例地址）
    seed_address = "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"  # 中本聪的第一个地址
    
    # 构建交易网络
    print("正在构建交易网络...")
    analyzer.build_transaction_graph(seed_address, depth=2)
    
    # 聚类分析
    print("正在进行地址聚类...")
    analyzer.cluster_addresses()
    
    # 异常检测
    print("正在检测异常交易...")
    anomalies = analyzer.detect_anomalies()
    print(f"发现 {len(anomalies)} 个异常交易")
    
    # 可视化
    print("正在生成可视化图表...")
    analyzer.visualize_transaction_graph()
    
    # 生成报告
    print("正在生成分析报告...")
    report = analyzer.generate_report()
    
    # 输出报告摘要
    print("\n===== 分析报告摘要 =====")
    print(f"总节点数: {report['graph_stats']['nodes']}")
    print(f"总边数: {report['graph_stats']['edges']}")
    print(f"地址簇数: {report['graph_stats']['clusters']}")
    print(f"异常交易数: {len(report['anomalies'])}")
    print(f"高价值地址数: {len(report['high_value_addresses'])}")
    if report['high_value_addresses']:
        print("\n前5个高价值地址:")
        for i, addr_info in enumerate(report['high_value_addresses'][:5]):
            print(f"{i+1}. {addr_info['address']}: {addr_info['balance']} BTC")