比特幣鏈上指標實戰應用：從數據到投資決策

概述

比特幣區塊鏈上產生的大量數據，為投資者提供了豐富的市場分析素材。不同於傳統金融市場的技術分析，比特幣的鏈上指標基於區塊鏈的真實交易活動，能夠提供更客觀、更難以操縱的市場洞察。本指南將深入探討各種重要的鏈上指標，包括它們的計算方法、數據解讀方式，以及如何在實際投資中應用這些指標。我們將提供具體的程式碼範例和數據視覺化方法，幫助讀者建立自己的鏈上分析系統。

無論您是希望深入研究比特幣的愛好者，還是正在尋找額外分析工具的投資者，本指南都將提供實用的知識與技能。透過理解這些指標的內在邏輯，您將能夠更準確地評估市場趨勢、識別潛在風險，並做出更有根據的投資決策。

比特幣區塊鏈數據基礎

區塊鏈數據的類型與來源

比特幣區塊鏈上的數據可以分為多個層次，每個層次都蘊含著獨特的市場資訊。理解這些數據類型是正確使用鏈上指標的前提。

區塊數據是最基本的區塊鏈資訊單位。每個區塊包含區塊頭（Block Header）和區塊體（Block Body）兩部分。區塊頭記錄了前一區塊的雜湊值、Merkle 根、難度目標、時間戳等元資訊，這些資料對於理解比特幣網路的運作狀態非常重要。區塊體則包含了該區塊內的所有交易，這些交易數據是計算各種鏈上指標的原始素材。

交易數據是區塊鏈分析的核心。每筆比特幣交易都包含輸入（Inputs）和輸出（Outputs），輸入代表被花費的比特幣，輸出代表新產生的未花費交易輸出（UTXO）。透過分析交易的輸入輸出，我們可以計算出各種有價值的指標，例如總交易量、活躍地址數、交易所流量等。

鏈上指標的數據來源主要有兩種途徑：直接運行比特幣節點或使用區塊鏈數據服務商。運行自己的比特幣節點可以獲得最完整、未經過濾的原始數據，但需要較高的技術門檻和硬體資源。區塊鏈數據服務商（如 Glassnode、Chainalysis、Blockstream）則提供了經過處理和索引的數據，使用上更為便利但通常需要付費訂閱。

獲取鏈上數據的方法

對於自行開發分析系統的投資者，有多種途徑可以獲取比特幣鏈上數據。以下介紹幾種常用的方法及其優劣。

第一種方法是直接使用 Bitcoin Core 的 RPC 介面。Bitcoin Core 提供了豐富的 RPC 命令，可以查詢區塊、交易、記憶池等各種數據。例如，使用 getblockchaininfo 可以獲取區塊鏈的基本資訊，使用 getrawmempool 可以查看當前記憶池中的所有交易，使用 listtransactions 可以查詢錢包交易紀錄。這種方法的優點是數據最原始、最可靠，缺點是需要運行完整的比特幣節點，且部分查詢操作較為耗時。

第二種方法是使用專門的區塊鏈索引服務。Bitcoin Core 的實作團隊提供了 electrum 協議，這是一種輕量級的區塊鏈查詢協議，可以在不運行完整節點的情況下查詢區塊鏈數據。此外，Blockstream 提供的 Blockstream Satellite 和 Blockstream API 也是常用的選擇。這種方法適合需要快速查詢但不想運行完整節點的開發者。

第三種方法是使用第三方數據 API。許多區塊鏈分析平台提供了付費或免費的 API 服務，常見的包括 CoinGecko（整合了多種區塊鏈數據）、Glassnode Studio、CryptoQuant 等。這些服務通常提供了已經計算好的各種鏈上指標，投資者可以直接使用而無需自行處理原始數據。以下是一個使用 Python 獲取區塊鏈數據的簡單範例：

import requests
import json
from datetime import datetime

class BitcoinOnChainDataFetcher:
    """比特幣鏈上數據獲取類別"""
    
    def __init__(self):
        self.base_url = "https://blockstream.info/api"
    
    def get_block_height(self):
        """獲取最新區塊高度"""
        response = requests.get(f"{self.base_url}/blocks/tip/height")
        return int(response.text)
    
    def get_block_hash(self, height):
        """獲取指定高度的區塊雜湊"""
        response = requests.get(f"{self.base_url}/block-height/{height}")
        return response.text
    
    def get_block_data(self, block_hash):
        """獲取區塊詳細數據"""
        response = requests.get(f"{self.base_url}/block/{block_hash}")
        return response.json()
    
    def get_address_balance(self, address):
        """獲取地址餘額"""
        response = requests.get(f"{self.base_url}/address/{address}/txs")
        transactions = response.json()
        
        # 計算餘額
        balance = 0
        for tx in transactions:
            for output in tx['vout']:
                if output['scriptpubkey_address'] == address:
                    balance += output['value']
            for input_info in tx['vin']:
                # 需要追蹤輸入來計算餘額的變化
                pass
        
        return balance
    
    def get_mempool_transactions(self):
        """獲取記憶池中的交易"""
        response = requests.get(f"{self.base_url}/mempool/txids")
        return response.json()

# 使用範例
fetcher = BitcoinOnChainDataFetcher()
current_height = fetcher.get_block_height()
print(f"最新區塊高度: {current_height}")

市場活躍度指標

活躍地址數分析

活躍地址數（Active Addresses）是衡量比特幣網路使用狀況最基本的指標之一。這個指標計算在特定時間週期內（通常是一天）有比特幣轉入或轉出的唯一地址數量。

活躍地址數的計算方法相對簡單：遍歷指定期間內的所有交易，收集所有出現在輸入或輸出中的比特幣地址，然後計算這些地址的唯一數量。這個數值反映了網路上實際進行比特幣轉移的用戶數量，是評估比特幣網路採用程度的重要指標。

從投資的角度來看，活躍地址數與比特幣價格之間存在一定的相關性。當價格上漲時，通常會吸引更多用戶進入市場，活躍地址數也會相應增加。反之，當市場轉冷時，活躍地址數也會下降。然而，這種關係並非絕對，有時會出現價格與活躍地址數背離的情況，這可能預示著趨勢的轉變。

以下是一個計算比特幣活躍地址數的 Python 程式碼範例：

import requests
from collections import Set
from datetime import datetime, timedelta

class ActiveAddressesCalculator:
    """比特幣活躍地址數計算器"""
    
    def __init__(self, api_base="https://blockstream.info/api"):
        self.api_base = api_base
    
    def get_daily_active_addresses(self, date):
        """
        計算指定日期的活躍地址數
        
        參數:
            date: datetime 對象或字串 'YYYY-MM-DD'
        返回:
            set: 活躍地址集合
        """
        if isinstance(date, str):
            date = datetime.strptime(date, '%Y-%m-%d')
        
        # 獲取該日期的區塊範圍
        start_timestamp = int(date.timestamp())
        end_timestamp = int((date + timedelta(days=1)).timestamp())
        
        active_addresses = set()
        
        # 遍歷記憶池和區塊獲取交易
        # 這是一個簡化的實現，生產環境需要更複雜的處理
        page = 0
        while True:
            response = requests.get(
                f"{self.api_base}/blocks",
                params={"start": page * 100, "limit": 100}
            )
            blocks = response.json()
            
            if not blocks:
                break
            
            for block in blocks:
                block_time = block['timestamp']
                
                # 只處理指定日期的區塊
                if block_time < start_timestamp:
                    return active_addresses
                
                if block_time >= start_timestamp and block_time < end_timestamp:
                    # 獲取區塊中的交易
                    for tx in block.get('tx', []):
                        # 收集所有輸入地址
                        for vin in tx.get('vin', []):
                            if 'prevout' in vin and 'scriptpubkey_address' in vin['prevout']:
                                active_addresses.add(vin['prevout']['scriptpubkey_address'])
                        
                        # 收集所有輸出地址
                        for vout in tx.get('vout', []):
                            if 'scriptpubkey_address' in vout:
                                active_addresses.add(vout['scriptpubkey_address'])
            
            page += 1
        
        return active_addresses
    
    def calculate_active_addresses_ratio(self, date):
        """
        計算活躍地址數與總地址數的比例
        
        這可以幫助識別網路的健康程度
        """
        active = self.get_daily_active_addresses(date)
        
        # 估算總地址數（這是一個近似值）
        # 實際上需要維護一個完整的地址索引
        estimated_total = 50000000  # 比特幣總地址數的估計值
        
        return len(active) / estimated_total

交易數量與交易量

交易數量（Transaction Count）是另一個重要的市場活躍度指標。這個指標記錄特定時間內比特幣網路上發生的總交易次數，反映了網路的實際使用頻率。

交易數量的解讀需要注意幾個要點。首先，比特幣交易可以分為鏈上交易和閃電網路交易。傳統上討論的交易數量通常指的是鏈上交易，但隨著閃電網路的發展，越來越多的比特幣交易發生在第二層網路上，這部分交易通常不會體現在鏈上交易數據中。因此，在解讀交易數據時，需要考慮閃電網路的影響。

其次，交易數量並不能直接反映實際的比特幣轉移量。一筆比特幣交易可以包含多個輸入和多個輸出，因此單純的交易數量無法準確衡量比特幣的實際流通量。這就是為什麼我們需要引入「調整後交易量」（Adjusted Transaction Volume）這個指標。

調整後交易量考虑了每筆交易的輸入和輸出金額，提供了更準確的比特幣流通量度量。這個指標的計算方法是将所有交易的輸入金額（不包括 Coinbase 交易）加總，通常以比特幣或美元計價。以下是一個計算調整後交易量的範例：

class TransactionVolumeAnalyzer:
    """比特幣交易量分析器"""
    
    def __init__(self, api_base="https://blockstream.info/api"):
        self.api_base = api_base
    
    def get_adjusted_transaction_volume(self, block_hash):
        """
        計算區塊的調整後交易量
        
        調整後交易量 = 所有輸入金額（排除 Coinbase）
        """
        response = requests.get(f"{self.api_base}/block/{block_hash}")
        block_data = response.json()
        
        total_volume = 0
        
        for tx in block_data.get('tx', []):
            # 跳過 Coinbase 交易
            if tx.get('vin', []) and 'coinbase' in tx['vin'][0]:
                continue
            
            # 計算輸入總額
            tx_input_volume = 0
            for vin in tx.get('vin', []):
                if 'prevout' in vin:
                    tx_input_volume += vin['prevout']['value']
            
            total_volume += tx_input_volume
        
        return {
            'block_hash': block_hash,
            'block_height': block_data.get('height'),
            'total_volume_satoshis': total_volume,
            'total_volume_btc': total_volume / 100000000,
            'transaction_count': len(block_data.get('tx', [])) - 1  # 排除 Coinbase
        }
    
    def get_daily_transaction_volume(self, date):
        """計算每日交易量"""
        # 獲取當天的所有區塊
        # 這裡需要根據日期確定區塊範圍
        # 簡化實現
        
        daily_volume = 0
        daily_tx_count = 0
        
        # 獲取最新的區塊
        response = requests.get(f"{self.api_base}/blocks/tip/height")
        current_height = int(response.text)
        
        # 假設每個區塊約 10 分鐘，每天約 144 個區塊
        start_height = current_height - 144
        
        for height in range(start_height, current_height + 1):
            response = requests.get(f"{self.api_base}/block-height/{height}")
            block_hash = response.text
            
            volume_data = self.get_adjusted_transaction_volume(block_hash)
            daily_volume += volume_data['total_volume_satoshis']
            daily_tx_count += volume_data['transaction_count']
        
        return {
            'date': date,
            'daily_volume_btc': daily_volume / 100000000,
            'daily_transaction_count': daily_tx_count,
            'average_transaction_size_btc': daily_volume / daily_tx_count / 100000000 if daily_tx_count > 0 else 0
        }

鏈上估值指標

Stock-to-Flow 模型

Stock-to-Flow（S2F）模型是比特幣領域最著名的估值模型之一。這個模型基於比特幣的供應機制，試圖建立比特幣價格與其稀缺性之間的數學關係。

Stock-to-Flow 的計算非常直觀：Stock（庫存）指的是目前流通中的比特幣總量，Flow（流量）指的是每年新增的比特幣數量。S2F = Stock / Flow。對於比特幣而言，由於每四年減半一次，Flow 會週期性地減少一半，因此 S2F 值會週期性地跳升。

S2F 模型的理論基礎是「供給稀缺性決定價值」。像黃金這樣的商品，由於供應量相對穩定（Flow 佔 Stock 的比例很低），因此具有較高的 S2F 值，長期以來被視為保值資產。比特幣的設計目標正是成為「數位黃金」，其 S2F 值隨著每次減半而逐漸接近甚至超越黃金。

以下是 S2F 模型計算的 Python 實現：

import math
from datetime import datetime

class StockToFlowModel:
    """比特幣 Stock-to-Flow 估值模型"""
    
    # 比特幣區塊獎勵歷史（每個區塊的 BTC 數量）
    HALVING_SCHEDULE = [
        (0, 50),      # 創世區塊開始
        (210000, 50), # 第一個減半週期
        (420000, 25), # 第二個減半週期
        (630000, 12.5), # 第三個減半週期
        (840000, 6.25), # 第四個減半週期
    ]
    
    def __init__(self, current_block_height):
        self.current_block_height = current_block_height
    
    def get_block_reward(self, block_height):
        """根據區塊高度獲取區塊獎勵"""
        for i in range(len(self.HALVING_SCHEDULE) - 1, -1, -1):
            if block_height >= self.HALVING_SCHEDULE[i][0]:
                return self.HALVING_SCHEDULE[i][1]
        return 0
    
    def calculate_total_supply(self, up_to_block_height=None):
        """
        計算比特幣總供應量
        
        參數:
            up_to_block_height: 計算到指定區塊高度，若為 None 則計算到當前區塊
        返回:
            float: 比特幣總供應量（BTC）
        """
        if up_to_block_height is None:
            up_to_block_height = self.current_block_height
        
        total_supply = 0
        
        # 計算每個減半週期的供應量
        for i in range(len(self.HALVING_SCHEDULE)):
            start_block = self.HALVING_SCHEDULE[i][0]
            reward = self.HALVING_SCHEDULE[i][1]
            
            # 確定這個週期的結束區塊
            if i < len(self.HALVING_SCHEDULE) - 1:
                end_block = self.HALVING_SCHEDULE[i + 1][0]
            else:
                # 對未來的估計（比特幣最多 2100 萬枚）
                end_block = 6930000  # 估計的最終區塊
            
            if up_to_block_height > start_block:
                blocks_in_period = min(up_to_block_height, end_block) - start_block
                total_supply += blocks_in_period * reward
        
        return total_supply
    
    def calculate_annual_flow(self):
        """
        計算年度流量（Flow）
        
        基於當前年化區塊獎勵
        """
        current_reward = self.get_block_reward(self.current_block_height)
        
        # 每年約 52560 個區塊（6 * 24 * 365）
        blocks_per_year = 52560
        
        annual_flow = current_reward * blocks_per_year
        
        return annual_flow
    
    def calculate_s2f(self):
        """
        計算 Stock-to-Flow 值
        """
        stock = self.calculate_total_supply()
        flow = self.calculate_annual_flow()
        
        return stock / flow
    
    def predict_price(self, s2f_model_factor=1.0):
        """
        根據 S2F 模型預測價格
        
        參數:
            s2f_model_factor: 模型參數，根據歷史數據擬合
        
        返回:
            float: 預測價格（美元）
        """
        s2f = self.calculate_s2f()
        
        # S2F 模型的簡單線性形式
        # 實際模型可能更複雜，需要根據歷史數據擬合
        predicted_price = (s2f ** 2) * s2f_model_factor
        
        return predicted_price
    
    def get_s2f_projection(self, years_ahead=10):
        """
        獲取未來 S2F 值的預測
        
        參數:
            years_ahead: 預測的年數
        
        返回:
            list: 每年的 S2F 預測值
        """
        # 假設每個區塊時間為 10 分鐘
        blocks_per_year = 52560
        
        projections = []
        current_height = self.current_block_height
        
        for year in range(1, years_ahead + 1):
            future_height = current_height + (blocks_per_year * year)
            future_supply = self.calculate_total_supply(future_height)
            
            # 假設未來減半按計劃進行
            future_reward = self.get_block_reward(future_height)
            future_flow = future_reward * blocks_per_year
            
            future_s2f = future_supply / future_flow
            
            projections.append({
                'year': year,
                'block_height': future_height,
                'total_supply': future_supply,
                'annual_flow': future_flow,
                's2f': future_s2f
            })
        
        return projections

比特幣市值與已實現市值

市值（Market Cap）和已實現市值（Realized Cap）是比特幣估值的兩個關鍵指標。理解這兩個指標的差異與應用，對於投資決策非常重要。

市值是最直觀的比特幣估值指標，計算方法為比特幣流通量乘以當前市場價格。這個指標的問題在於，它將所有比特幣視為同等價值，包括多年未移動的「丟失比特幣」和長期持有的比特幣。這種計算方式可能會高估比特幣的實際市場價值。

已實現市值則是一種更精細的估值方法。它的計算方式是將每個 UTXO（未花費交易輸出）按照其最後一次移動時的價格進行估值，然後加總所有 UTXO 的價值。換話說，已實現市值反映句的是比特幣網路上實際「活躍」的價值，而非僅僅是當前市價計算的理論價值。

已實現市值的優點在於，它能夠過濾掉長期持有者的持幣成本，特別是早期投資者的低價比特幣。這使得已實現市值更能反映當前市場參與者的平均成本基礎。當比特幣市價大幅偏離已實現市值時，可能預示著市場處於極端狀態。

以下程式碼展示了如何計算比特幣的已實現市值：

class RealizedCapCalculator:
    """比特幣已實現市值計算器"""
    
    def __init__(self, api_base="https://blockstream.info/api"):
        self.api_base = api_base
        self.utxo_cache = {}
    
    def get_utxo_set(self, address):
        """獲取地址的 UTXO 集合"""
        response = requests.get(f"{self.base_url}/address/{address}/utxo")
        return response.json()
    
    def estimate_realized_cap(self, current_price_usd):
        """
        估算已實現市值
        
        這是一個簡化的實現，生產環境需要更完整的 UTXO 索引
        這裡我們使用歷史價格數據來估算
        
        參數:
            current_price_usd: 當前比特幣價格（美元）
        
        返回:
            dict: 估算結果
        """
        # 這是一個複雜的計算，需要維護完整的 UTXO 索引
        # 我們這裡提供概念性的實現
        
        # 已實現市值的關鍵洞見：
        # - 近期移動的比特幣使用較高的價格估值
        # - 長期未移動的比特幣使用較低的歷史價格估值
        
        # 簡化的估算方法
        # 假設不同年齡的比特幣佔總供應量的不同比例
        
        supply_distribution = {
            'less_than_1_month': 0.15,      # 15% 在一個月內移動
            '1_to_6_months': 0.15,          # 15% 在 1-6 個月內移動
            '6_to_12_months': 0.10,         # 10% 在 6-12 個月內移動
            '1_to_2_years': 0.15,           # 15% 在 1-2 年內移動
            '2_to_5_years': 0.20,           # 20% 在 2-5 年內移動
            'more_than_5_years': 0.25        # 25% 超過 5 年未移動
        }
        
        # 假設不同年齡的比特幣有不同的平均成本
        # 這是一個簡化的估算
        cost_basis_ratios = {
            'less_than_1_month': 0.9,       # 近期的成本約為現價的 90%
            '1_to_6_months': 0.75,
            '6_to_12_months': 0.60,
            '1_to_2_years': 0.40,
            '2_to_5_years': 0.20,
            'more_than_5_years': 0.05        # 早期比特幣成本極低
        }
        
        total_bitcoin_supply = 19700000  # 比特幣總供應量（約）
        
        realized_value = 0
        
        for period, ratio in supply_distribution.items():
            bitcoin_amount = total_bitcoin_supply * ratio
            cost_basis = current_price_usd * cost_basis_ratios[period]
            realized_value += bitcoin_amount * cost_basis
        
        return {
            'estimated_realized_cap_usd': realized_value,
            'current_market_cap_usd': total_bitcoin_supply * current_price_usd,
            'market_to_realized_ratio': (total_bitcoin_supply * current_price_usd) / realized_value
        }
    
    def calculate_mvrv_ratio(self, market_cap, realized_cap):
        """
        計算 MVRV 比率
        
        MVRV = 市值 / 已實現市值
        
        這個比率可以用於識別比特幣的市場週期：
        - MVRV < 1: 市場底部區域
        - MVRV > 1: 市場上漲趨勢
        - MVRV > 3-4: 市場頂部風險增加
        """
        return market_cap / realized_cap if realized_cap > 0 else 0

投資者行為指標

長期持有者供給

長期持有者（Long-Term Holders, LTH）供給是評估比特幣市場趨勢的重要指標。這個指標追蹤的是一段時間未被移動的比特幣數量，通常以 155 天（約 5 個月）作為長期持有的門檻。

長期持有者供給的邏輯很直觀：當比特幣價格上漲時，長期持有者更傾向於繼續持有，等待更高的價格，這會減少市場上的流通供給。反之，當價格下跌時，長期持有者可能會恐慌性拋售，增加市場供給。

分析長期持有者供給的變化趨勢，可以幫助投資者識別市場週期的轉折點。例如，當長期持有者供給開始快速增加時，可能預示著市場進入累積階段；當長期持有者開始拋售時，可能預示著市場接近頂部。

以下是一個分析長期持有者供給的 Python 程式碼範例：

class LongTermHolderAnalyzer:
    """比特幣長期持有者分析器"""
    
    # 長期持有的定義（天數）
    LTH_THRESHOLD_DAYS = 155
    
    def __init__(self, api_base="https://blockstream.info/api"):
        self.api_base = api_base
    
    def analyze_lth_supply(self, block_height, block_time):
        """
        分析長期持有者供給
        
        參數:
            block_height: 區塊高度
            block_time: 區塊時間戳
        
        返回:
            dict: 分析結果
        """
        # 計算 LTH 門檻區塊
        # 假設每個區塊約 10 分鐘
        blocks_per_day = 144
        threshold_blocks = self.LTH_THRESHOLD_DAYS * blocks_per_day
        threshold_block = block_height - threshold_blocks
        
        # 這裡需要獲取歷史 UTXO 數據
        # 簡化的估算方法
        
        # 概念性的 LTH 供給分析
        lth_analysis = {
            'current_block_height': block_height,
            'lth_threshold_block': threshold_block,
            'lth_supply_percentage': 0.0,  # 需要完整數據計算
            'lth_supply_change_30d': 0.0,
            'interpretation': ''
        }
        
        # LTH 供給解讀
        # 高 LTH 供給（>70%）通常表示：
        # - 市場累積階段
        # - 投資者信心強
        # - 拋售壓力低
        
        # 低 LTH 供給（<40%）通常表示：
        # - 市場分發階段
        # - 獲利了結增加
        # - 潛在頂部信號
        
        return lth_analysis
    
    def detect_lth_behavior_change(self, historical_data):
        """
        檢測長期持有者行為變化
        
        參數:
            historical_data: 歷史 LTH 數據
        
        返回:
            dict: 行為變化分析
        """
        if len(historical_data) < 2:
            return {'error': 'Insufficient data'}
        
        # 計算 LTH 供給的變化率
        latest = historical_data[-1]
        previous = historical_data[-2]
        
        change_rate = (latest['lth_supply'] - previous['lth_supply']) / previous['lth_supply']
        
        # 識別行為模式
        behavior = 'neutral'
        if change_rate > 0.05:
            behavior = 'accumulation'  # 累積
        elif change_rate < -0.05:
            behavior = 'distribution'  # 分發
        
        return {
            'change_rate': change_rate,
            'behavior': behavior,
            'signal': self._get_behavior_signal(behavior)
        }
    
    def _get_behavior_signal(self, behavior):
        """根據行為類型生成投資信號"""
        signals = {
            'accumulation': {
                'bullish': True,
                'description': '長期持有者正在累積比特幣，這通常是牛市初期的信號',
                'action': '考慮逢低買入'
            },
            'distribution': {
                'bullish': False,
                'description': '長期持有者正在分發比特幣，這可能是市場頂部的信號',
                'action': '考慮獲利了結或減少倉位'
            },
            'neutral': {
                'bullish': None,
                'description': '長期持有者行為穩定',
                'action': '保持現有策略'
            }
        }
        return signals.get(behavior, signals['neutral'])

交易所流量分析

交易所流量分析是另一個重要的鏈上指標。透過追蹤比特幣流入和流出交易所的數量，我們可以了解市場參與者的行為模式。

一般來說，當比特幣大量流入交易所時，表明投資者準備出售，這可能是潛在的拋售壓力信號。當比特幣大量流出交易所時，表明投資者正在將比特幣轉入個人錢包，可能是長期持有的信號。

然而，這種解讀需要結合具體的市場環境。有時大量流入可能是機構投資者準備進場買入，大量流出可能是機構投資者完成建倉後將比特幣轉入冷錢包。因此，在解讀交易所流量數據時，需要考慮更多的上下文資訊。

class ExchangeFlowAnalyzer:
    """比特幣交易所流量分析器"""
    
    # 主要交易所地址（簡化示例）
    KNOWN_EXCHANGE_ADDRESSES = {
        'Binance': ['bc1q...', '3D...'],  # 實際需要完整列表
        'Coinbase': ['bc1q...', '3D...'],
        'Kraken': ['bc1q...', '3D...'],
    }
    
    def __init__(self, api_base="https://blockstream.info/api"):
        self.api_base = api_base
    
    def get_address_transactions(self, address, limit=50):
        """獲取地址的交易歷史"""
        response = requests.get(f"{self.base_url}/address/{address}/txs")
        return response.json()[:limit]
    
    def calculate_exchange_flow(self, address, days=7):
        """
        計算交易所的比特幣流量
        
        參數:
            address: 交易所地址
            days: 計算的天數
        
        返回:
            dict: 流量分析結果
        """
        transactions = self.get_address_transactions(address, limit=1000)
        
        total_inflow = 0      # 流入（比特幣）
        total_outflow = 0     # 流出（比特幣）
        inflow_count = 0      # 流入交易數
        outflow_count = 0    # 流出交易數
        
        for tx in transactions:
            # 分析交易的輸入和輸出
            for vin in tx.get('vin', []):
                if 'prevout' in vin:
                    # 這是一個輸入，資金流入地址
                    total_inflow += vin['prevout']['value']
                    inflow_count += 1
            
            for vout in tx.get('vout', []):
                # 這是一個輸出，資金流出地址
                if 'scriptpubkey_address' in vout:
                    total_outflow += vout['value']
                    outflow_count += 1
        
        # 轉換為比特幣
        total_inflow_btc = total_inflow / 100000000
        total_outflow_btc = total_outflow / 100000000
        
        net_flow = total_inflow_btc - total_outflow_btc
        
        return {
            'address': address,
            'period_days': days,
            'total_inflow_btc': total_inflow_btc,
            'total_outflow_btc': total_outflow_btc,
            'net_flow_btc': net_flow,
            'inflow_count': inflow_count,
            'outflow_count': outflow_count,
            'interpretation': self._interpret_flow(net_flow)
        }
    
    def _interpret_flow(self, net_flow):
        """解讀流量信號"""
        if net_flow > 1000:  # 比特幣
            return {
                'signal': 'strong_inflow',
                'interpretation': '大量比特幣流入交易所，可能預示拋售壓力增加',
                'action': '謹慎觀察'
            }
        elif net_flow > 100:
            return {
                'signal': 'moderate_inflow',
                'interpretation': '適量比特幣流入交易所',
                'action': '持續監控'
            }
        elif net_flow < -1000:
            return {
                'signal': 'strong_outflow',
                'interpretation': '大量比特幣流出交易所，可能預示長期持有或分發完成',
                'action': '關注長期趨勢'
            }
        elif net_flow < -100:
            return {
                'signal': 'moderate_outflow',
                'interpretation': '適量比特幣流出交易所',
                'action': '持續監控'
            }
        else:
            return {
                'signal': 'neutral',
                'interpretation': '交易所流量穩定',
                'action': '保持觀察'
            }
    
    def aggregate_market_flow(self, exchange_addresses, days=7):
        """
        聚合多個交易所的流量數據
        
        這可以提供整體市場的交易所流量概況
        """
        total_inflow = 0
        total_outflow = 0
        
        for address in exchange_addresses:
            flow = self.calculate_exchange_flow(address, days)
            total_inflow += flow['total_inflow_btc']
            total_outflow += flow['total_outflow_btc']
        
        return {
            'total_inflow_btc': total_inflow,
            'total_outflow_btc': total_outflow,
            'net_flow_btc': total_inflow - total_outflow,
            'exchange_to_total_supply_ratio': (total_inflow + total_outflow) / 19700000
        }

鏈上指標的綜合應用

建立多指標評估系統

將多個鏈上指標結合起來，可以形成更全面的市場評估框架。以下是一個示例性的多指標評估系統：

class OnChainInvestmentSystem:
    """比特幣鏈上投資決策系統"""
    
    def __init__(self, current_price_usd, block_height):
        self.current_price_usd = current_price_usd
        self.block_height = block_height
        self.s2f_model = StockToFlowModel(block_height)
        self.rhc_calculator = RealizedCapCalculator()
        self.lth_analyzer = LongTermHolderAnalyzer()
        self.exchange_flow = ExchangeFlowAnalyzer()
    
    def generate_market_report(self):
        """生成綜合市場報告"""
        
        # 計算各項指標
        s2f_value = self.s2f_model.calculate_s2f()
        predicted_price = self.s2f_model.predict_price()
        
        realized_cap = self.rhc_calculator.estimate_realized_cap(self.current_price_usd)
        market_cap = 19700000 * self.current_price_usd
        mvrv_ratio = realized_cap['market_to_realized_ratio']
        
        # 根據指標生成信號
        signals = []
        
        # S2F 信號
        s2f_signal = self._evaluate_s2f(s2f_value)
        signals.append(s2f_signal)
        
        # MVRV 信號
        mvrv_signal = self._evaluate_mvrv(mvrv_ratio)
        signals.append(mvrv_signal)
        
        # 計算整體評分
        bullish_count = sum(1 for s in signals if s.get('bullish') == True)
        bearish_count = sum(1 for s in signals if s.get('bullish') == False)
        
        if bullish_count > bearish_count:
            overall_signal = 'bullish'
        elif bearish_count > bullish_count:
            overall_signal = 'bearish'
        else:
            overall_signal = 'neutral'
        
        return {
            'current_price': self.current_price_usd,
            's2f_value': s2f_value,
            'predicted_price_s2f': predicted_price,
            'realized_cap': realized_cap['estimated_realized_cap_usd'],
            'mvrv_ratio': mvrv_ratio,
            'individual_signals': signals,
            'overall_signal': overall_signal,
            'recommendation': self._generate_recommendation(overall_signal, signals)
        }
    
    def _evaluate_s2f(self, s2f_value):
        """評估 S2F 信號"""
        # 黃金的 S2F 約為 60
        # 比特幣減半後預期達到 100+
        
        if s2f_value > 100:
            return {
                'indicator': 'Stock-to-Flow',
                'value': s2f_value,
                'bullish': True,
                'interpretation': 'S2F 值處於歷史高點，供應稀缺性顯著'
            }
        elif s2f_value > 50:
            return {
                'indicator': 'Stock-to-Flow',
                'value': s2f_value,
                'bullish': None,
                'interpretation': 'S2F 值處於正常區間'
            }
        else:
            return {
                'indicator': 'Stock-to-Flow',
                'value': s2f_value,
                'bullish': False,
                'interpretation': 'S2F 值較低，供應相對充足'
            }
    
    def _evaluate_mvrv(self, mvrv_ratio):
        """評估 MVRV 信號"""
        
        if mvrv_ratio < 1.0:
            return {
                'indicator': 'MVRV Ratio',
                'value': mvrv_ratio,
                'bullish': True,
                'interpretation': '市場嚴重低估，長期投資者具吸引力'
            }
        elif mvrv_ratio < 1.5:
            return {
                'indicator': 'MVRV Ratio',
                'value': mvrv_ratio,
                'bullish': None,
                'interpretation': '市場處於合理區間'
            }
        elif mvrv_ratio < 3.0:
            return {
                'indicator': 'MVRV Ratio',
                'value': mvrv_ratio,
                'bullish': False,
                'interpretation': '市場處於高估狀態'
            }
        else:
            return {
                'indicator': 'MVRV Ratio',
                'value': mvrv_ratio,
                'bullish': False,
                'interpretation': '市場處於極度高估，頂部風險增加'
            }
    
    def _generate_recommendation(self, overall_signal, signals):
        """生成投資建議"""
        
        recommendations = {
            'bullish': {
                'action': '考慮增加比特幣配置',
                'risk_level': '中等',
                'time_horizon': '長期'
            },
            'bearish': {
                'action': '考慮減少比特幣配置或觀望',
                'risk_level': '較高',
                'time_horizon': '短期或觀察'
            },
            'neutral': {
                'action': '維持當前配置',
                'risk_level': '適中',
                'time_horizon': '保持觀察'
            }
        }
        
        return recommendations.get(overall_signal)

結論

比特幣鏈上指標為投資者提供了傳統金融市場無法比擬的豐富數據資源。透過分析這些指標，我們可以更深入地理解市場參與者的行為模式，識別市場週期的轉折點，並做出更有根據的投資決策。

本指南介紹了多個重要的鏈上指標，包括活躍地址數、交易量、Stock-to-Flow 模型、已實現市值、長期持有者供給和交易所流量等。每個指標都有其獨特的價值，但也存在局限性。投資者在使用這些指標時，應該綜合考慮多個因素，而非依賴單一指標。

最重要的是，鏈上指標應該與其他分析方法（如技術分析、宏觀經濟分析）結合使用，形成完整的投資決策框架。同時，由於比特幣市場的高波動性和新興性，任何分析方法都無法保證投資成功，投資者應該始終保持謹慎的態度，做好風險管理。