Tardis Bitstamp 现货 Orderbook データへの HolySheep 経由アクセスと跨所アービトラージ分析アーカイブ

暗号通貨取引所の板情報（Orderbook）からアービトラージ機会を分析するシステムは、高頻度なデータ取得と低レイテンシーが 要求されます。HolySheep AI は、ChatGPT 系・Claude 系・Gemini 系・DeepSeek 系モデルへの統一エンドポイントを提供し、¥1=$1 の為替レートで 米ドル建て API コストを日本円換算した場合に最大85%のコスト削減を実現します。

本稿では、Tardis.dev の Bitstamp 现货 Exchange API を HolySheep 経由で呼び出し、リアルタイム Orderbook を取得・比較・アーカイブする Python 実装を詳解します。登録済みユーザーは¥1=$1の為替レートで GPT-4.1 $8/MTok・Claude Sonnet 4.5 $15/MTok・Gemini 2.5 Flash $2.50/MTok・DeepSeek V3.2 $0.42/MTok を活用でき、1000万トークン/月 使用時のコスト構造を具体的な数値で比較します。

本稿で構築するシステムの全体構成

Bitstamp 交易所の板情報から異なる取引所間の価格差（スプレッド）を検出し、アービトラージ機会を記録する Pipeline は以下の3層で構成されます：

• データ収集層：Tardis HTTP API → Bitstamp 现货 Orderbook JSON
• 分析・比較層：HolySheep AI（DeepSeek V3.2 低价推論）→ スプレッド計算とシグナル生成
• アーカイブ層：SQLite/PostgreSQL + 時系列インデックス

前提環境と必要な認証情報

# 必要な Python パッケージ（requirements.txt）
requests==2.31.0
pandas==2.2.2
sqlite-utils==3.36
python-dotenv==1.0.1
holy-sdk @ git+https://github.com/holysheep/[email protected]

# .env ファイル構成
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
TARDIS_API_KEY=your_tardis_api_key_here
BITSTAMP_CLIENT_ID=your_bitstamp_client_id
BITSTAMP_API_KEY=your_bitstamp_key
BITSTAMP_SECRET=your_bitstamp_secret
DATABASE_PATH=./arbitrage_archive.db
LOG_LEVEL=INFO

Step 1：Tardis Bitstamp Orderbook 取得の実装

Tardis.dev は криптобиржи のリアルタイム市場データを REST/WebSocket で配信する SaaS です。Bitstamp 交易所の板情報にアクセスするには Tardis API の endpoint を使用しますが、本稿では HolySheep の統一 Gateway を通じて認証・レート制限を統一管理し、DeepSeek V3.2 で Orderbook 解析を行います。Tardis 側の API キーは市場データ購読料として別途発生します。

import os
import json
import time
import sqlite3
from datetime import datetime, timezone
from dataclasses import dataclass, field
from typing import Optional
from pathlib import Path
import requests
import pandas as pd
from dotenv import load_dotenv

load_dotenv()

@dataclass
class OrderbookSnapshot:
    """板情報スナップショット"""
    exchange: str
    symbol: str
    timestamp: float  # Unix time (ms)
    bids: list[tuple[float, float]]  # [(price, volume), ...]
    asks: list[tuple[float, float]]  # [(price, volume), ...]
    best_bid: float = 0.0
    best_ask: float = 0.0
    spread_bps: float = 0.0  # basis points

    def __post_init__(self):
        if self.bids:
            self.best_bid = max(self.bids, key=lambda x: x[0])[0]
        if self.asks:
            self.best_ask = min(self.asks, key=lambda x: x[0])[0]
        if self.best_bid > 0 and self.best_ask > 0:
            self.spread_bps = round(
                (self.best_ask - self.best_bid) / self.best_bid * 10000, 2
            )


class TardisBitstampClient:
    """Tardis.dev API 経由の Bitstamp 现货 Orderbook 取得クライアント"""

    BASE_URL = "https://api.tardis.dev/v1"

    def __init__(self, tardis_api_key: str):
        self.api_key = tardis_api_key
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        })
        self._latency_log = []

    def get_realtime_orderbook(
        self,
        symbol: str = "BTC/USD",
        exchange: str = "bitstamp"
    ) -> Optional[OrderbookSnapshot]:
        """
        Tardis HTTP API から Bitstamp の現物板情報を取得
        返り値: OrderbookSnapshot または None
        """
        url = f"{self.BASE_URL}/feeds/{exchange}:{symbol}"
        params = {"type": "orderbook", "format": "native"}

        t0 = time.perf_counter()
        try:
            response = self.session.get(url, params=params, timeout=5)
            elapsed_ms = (time.perf_counter() - t0) * 1000
            self._latency_log.append(elapsed_ms)

            if response.status_code == 200:
                data = response.json()
                return self._parse_orderbook_response(exchange, symbol, data)
            else:
                print(f"[WARN] HTTP {response.status_code}: {response.text[:100]}")
                return None
        except requests.RequestException as e:
            print(f"[ERROR] Connection failed: {e}")
            return None

    def _parse_orderbook_response(
        self,
        exchange: str,
        symbol: str,
        data: dict
    ) -> OrderbookSnapshot:
        """Native format の Orderbook レスポンスをパース"""
        bids_raw = data.get("bids", []) or []
        asks_raw = data.get("asks", []) or []

        # Tardis native: [[price, volume], ...]
        bids = [(float(p), float(v)) for p, v in bids_raw[:20]]
        asks = [(float(p), float(v)) for p, v in asks_raw[:20]]

        ts = data.get("timestamp") or data.get("localTimestamp")
        if isinstance(ts, str):
            ts = datetime.fromisoformat(ts.replace("Z", "+00:00")).timestamp() * 1000

        return OrderbookSnapshot(
            exchange=exchange,
            symbol=symbol,
            timestamp=ts or time.time() * 1000,
            bids=bids,
            asks=asks
        )

    def get_avg_latency_ms(self) -> float:
        if not self._latency_log:
            return 0.0
        return round(sum(self._latency_log) / len(self._latency_log), 2)


class ArbitrageArchiveDB:
    """SQLite アーカイバ：Orderbook スナップショット＋スプレッド履歴"""

    def __init__(self, db_path: str):
        self.db_path = db_path
        self._init_schema()

    def _init_schema(self):
        with sqlite3.connect(self.db_path) as conn:
            conn.execute("""
                CREATE TABLE IF NOT EXISTS orderbook_snapshots (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    exchange TEXT NOT NULL,
                    symbol TEXT NOT NULL,
                    timestamp_ms INTEGER NOT NULL,
                    best_bid REAL NOT NULL,
                    best_ask REAL NOT NULL,
                    spread_bps REAL NOT NULL,
                    bids_json TEXT NOT NULL,
                    asks_json TEXT NOT NULL,
                    recorded_at TEXT DEFAULT CURRENT_TIMESTAMP
                )
            """)
            conn.execute("""
                CREATE INDEX IF NOT EXISTS idx_ts ON orderbook_snapshots(timestamp_ms)
            """)
            conn.execute("""
                CREATE INDEX IF NOT EXISTS idx_spread ON orderbook_snapshots(spread_bps)
            """)

            conn.execute("""
                CREATE TABLE IF NOT EXISTS arbitrage_signals (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    signal_ts INTEGER NOT NULL,
                    symbol TEXT NOT NULL,
                    exchange_a TEXT NOT NULL,
                    exchange_b TEXT NOT NULL,
                    price_a REAL NOT NULL,
                    price_b REAL NOT NULL,
                    spread_bps REAL NOT NULL,
                    direction TEXT NOT NULL,
                    llm_analysis TEXT,
                    created_at TEXT DEFAULT CURRENT_TIMESTAMP
                )
            """)
            conn.commit()

    def save_snapshot(self, snapshot: OrderbookSnapshot):
        with sqlite3.connect(self.db_path) as conn:
            conn.execute("""
                INSERT INTO orderbook_snapshots
                (exchange, symbol, timestamp_ms, best_bid, best_ask,
                 spread_bps, bids_json, asks_json)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            """, (
                snapshot.exchange,
                snapshot.symbol,
                int(snapshot.timestamp),
                snapshot.best_bid,
                snapshot.best_ask,
                snapshot.spread_bps,
                json.dumps(snapshot.bids),
                json.dumps(snapshot.asks)
            ))
            conn.commit()

    def save_signal(
        self,
        signal_ts: int,
        symbol: str,
        ex_a: str,
        ex_b: str,
        price_a: float,
        price_b: float,
        spread_bps: float,
        direction: str,
        llm_analysis: Optional[str] = None
    ):
        with sqlite3.connect(self.db_path) as conn:
            conn.execute("""
                INSERT INTO arbitrage_signals
                (signal_ts, symbol, exchange_a, exchange_b, price_a, price_b,
                 spread_bps, direction, llm_analysis)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
            """, (
                signal_ts, symbol, ex_a, ex_b, price_a, price_b,
                spread_bps, direction, llm_analysis
            ))
            conn.commit()

    def get_recent_opportunities(self, min_spread_bps: float = 50, limit: int = 20):
        """直近の機会記録を取得"""
        with sqlite3.connect(self.db_path) as conn:
            df = pd.read_sql("""
                SELECT * FROM arbitrage_signals
                WHERE spread_bps >= ?
                ORDER BY signal_ts DESC
                LIMIT ?
            """, conn, params=(min_spread_bps, limit))
        return df


===== HolySheep AI LLM 分析クライアント =====
import openai

class HolySheepLLMClient:
    """
    HolySheep AI 統一エンドポイント経由の LLM クライアント。
    base_url: https://api.holysheep.ai/v1
    ※ api.openai.com / api.anthropic.com への参照禁止
    """
    BASE_URL = "https://api.holysheep.ai/v1"

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.client = openai.OpenAI(
            base_url=self.BASE_URL,
            api_key=self.api_key,
            timeout=30.0
        )

    def analyze_spread_opportunity(
        self,
        symbol: str,
        exchange_a: str,
        price_a: float,
        exchange_b: str,
        price_b: float,
        spread_bps: float,
        model: str = "deepseek-v3.2"  # $0.42/MTok — 最安値
    ) -> str:
        """
        スプレッド機会を DeepSeek V3.2 で分析し、自然言語サマリーを返す。
        HolySheep 経由: ¥1=$1 → $0.42/MTok = ¥0.42/MTok（公式比85%安い）
        """
        prompt = f"""あなたは暗号通貨アービトラージ分析エキスパートです。
以下の市場データから短期的な裁定機会を評価してください：

取引ペア: {symbol}
{A} ({exchange_a}) 買い気配: ${price_a:,.2f}
{B} ({exchange_b}) 売り気配: ${price_b:,.2f}
スプレッド: {spread_bps} bps ({spread_bps/100:.2f}%)

評価項目:
1. このスプレッドは現実的なアービトラージ機会か？（取引手数料・スリッページを考慮）
2. 流動性は十分か？
3. 推奨される対応行動は？

JSON フォーマットで返答してください:
{{"opportunity_score": 0-100, "feasible": true/false, "reason": "説明", "action": "推奨行動"}}
"""
        response = self.client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": "あなたは暗号通貨市場のデータ分析アシスタントです。"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.2,
            max_tokens=512
        )
        return response.choices[0].message.content


===== メイン Orchestrator =====
class ArbitrageMonitor:
    """
    Bitstamp Orderbook 監視 → HolySheep LLM 分析 → SQLite アーカイバ
    """

    def __init__(self):
        self.holysheep = HolySheepLLMClient(os.getenv("HOLYSHEEP_API_KEY"))
        self.tardis = TardisBitstampClient(os.getenv("TARDIS_API_KEY"))
        self.db = ArbitrageArchiveDB(os.getenv("DATABASE_PATH"))
        self.interval_sec = int(os.getenv("POLL_INTERVAL_SEC", "5"))
        self._running = False

    def run_once(self):
        """1サイクル: データ取得 → LLM分析 → 保存"""
        snapshot = self.tardis.get_realtime_orderbook("BTC/USD", "bitstamp")
        if snapshot is None:
            print(f"[{datetime.now():%H:%M:%S}] データ取得失敗")
            return

        self.db.save_snapshot(snapshot)
        avg_lat = self.tardis.get_avg_latency_ms()

        # スプレッド > 50 bps を機会候補として記録
        if snapshot.spread_bps >= 50:
            ts = int(snapshot.timestamp)
            llm_result = self.holysheep.analyze_spread_opportunity(
                symbol=snapshot.symbol,
                exchange_a="bitstamp",
                price_a=snapshot.best_bid,
                exchange_b="bitstamp_internal",
                price_b=snapshot.best_ask,
                spread_bps=snapshot.spread_bps
            )
            self.db.save_signal(
                signal_ts=ts,
                symbol=snapshot.symbol,
                ex_a="bitstamp",
                ex_b="bitstamp",
                price_a=snapshot.best_bid,
                price_b=snapshot.best_ask,
                spread_bps=snapshot.spread_bps,
                direction="bid_vs_ask",
                llm_analysis=llm_result
            )
            print(f"[{datetime.now():%H:%M:%S}] 📊 BTC/USD スプレッド: "
                  f"{snapshot.spread_bps}bps | LLM分析完了 (latency={avg_lat}ms)")

    def run_continuous(self, duration_min: Optional[int] = None):
        """連続監視モード"""
        self._running = True
        end_time = None
        if duration_min:
            end_time = time.time() + duration_min * 60

        print(f"[INFO] 監視開始 (interval={self.interval_sec}s, HolySheep=<50ms)")
        print(f"[INFO] HolySheep 利用モデル: deepseek-v3.2 @ $0.42/MTok")
        print(f"[INFO] 為替レート: ¥1=$1 (公式比85%割引)")

        while self._running:
            self.run_once()
            if end_time and time.time() >= end_time:
                break
            time.sleep(self.interval_sec)

        print(f"[INFO] 監視終了. 平均APIレイテンシ: {self.tardis.get_avg_latency_ms()}ms")


if __name__ == "__main__":
    monitor = ArbitrageMonitor()
    monitor.run_continuous(duration_min=10)

Step 2：HolySheep 経由のマルチ取引所比較クエリ（Gemini Flash 活用）

複数の取引所（Bitstamp, Kraken, Coinbase）から BTC/USD の板を並列取得し、Gemini 2.5 Flash（$2.50/MTok）で裁定機会をランキングする拡張スクリプトを実装します。HolySheep の ¥1=$1 為替レートを活用すると、¥2.50/MTok で Gemini 2.5 Flash が利用可能となり、美国公式の $2.50/MTok（約¥18.25/MTok）と比較して85%，成本削減になります。

 str:
        """
        Gemini 2.5 Flash ($2.50/MTok) で取引所ランキング分析
        HolySheep ¥1=$1 → ¥2.50/MTok（公式比85%安い）
        呼び出しコスト: 1クエリ ~2,000トークン = 約¥5（$0.005）
        """
        spreads_json = json.dumps(spreads, indent=2)

        prompt = f"""以下の{BTC/USD}現物取引所の気配データから、
最も有利なアービトラージ機会を提案してください：

{spreads_json}

分析タスク:
1. 買い возможность（最安値で買って最高値で売る機会）を特定
2. 各取引所の流動性スコアを計算（気配量合計ベース）
3. 裁定取引可行性（手数料0.1%以内）を判定
4. 優先順位を付けて結果を返す

JSON フォーマット:
{{
  "best_arbitrage": {{
    "buy_exchange": "...",
    "sell_exchange": "...",
    "expected_profit_bps": number,
    "liquidity_adequate": true/false,
    "feasible": true/false
  }},
  "ranking": [{{"exchange": "...", "score": number, "notes": "..."}}],
  "risk_factors": ["..."]
}}
"""

        response = self.client.chat.completions.create(
            model="gemini-2.5-flash",
            messages=[
                {
                    "role": "system",
                    "content": "あなたは暗号通貨マルチ取引所分析エキスパートです。"
                },
                {"role": "user", "content": prompt}
            ],
            temperature=0.3,
            max_tokens=1024
        )

        content = response.choices[0].message.content
        usage = response.usage

        # コスト計算（HolySheep ¥1=$1 レート）
        input_cost_usd = (usage.prompt_tokens / 1_000_000) * 2.50
        output_cost_usd = (usage.completion_tokens / 1_000_000) * 2.50
        total_cost_jpy = round((input_cost_usd + output_cost_usd) * 1.0, 4)

        print(f"[COST] Gemini 2.5 Flash 分析コスト: ¥{total_cost_jpy}")
        print(f"  Input tokens: {usage.prompt_tokens:,}")
        print(f"  Output tokens: {usage.completion_tokens:,}")

        return content

    def cost_estimate_table(self) -> dict:
        """
        HolySheep ¥1=$1 レートのコスト比較表を生成
        月間1,000万トークン使用時の月額コスト
        """
        # 公式レート: ¥7.3 = $1 → 逆算: $1 = ¥7.3
        holy_rate_jpy = 1.0  # ¥1 = $1 (HolySheep)
        official_rate_jpy = 7.3  # ¥7.3 = $1 (公式)

        models = [
            ("GPT-4.1", 8.00),
            ("Claude Sonnet 4.5", 15.00),
            ("Gemini 2.5 Flash", 2.50),
            ("DeepSeek V3.2", 0.42),
        ]

        monthly_tokens = 10_000_000
        table = {}

        for name, price_per_mtok in models:
            official_monthly_jpy = (monthly_tokens / 1_000_000) * price_per_mtok * official_rate_jpy
            holy_monthly_jpy = (monthly_tokens / 1_000_000) * price_per_mtok * holy_rate_jpy
            savings_jpy = official_monthly_jpy - holy_monthly_jpy
            savings_pct = round(savings_jpy / official_monthly_jpy * 100, 1)

            table[name] = {
                "1Mtok_cost_official_jpy": round(official_monthly_jpy, 2),
                "1Mtok_cost_holysheep_jpy": holy_monthly_jpy,
                "monthly_10M_cost_jpy": round(holy_monthly_jpy, 2),
                "monthly_10M_savings_jpy": round(savings_jpy, 2),
                "savings_pct": savings_pct,
                "latency": "<50ms (HolySheep)"
            }

        return table


def simulate_multi_exchange_comparison():
    """ダミーデータで Gemini 2.5 Flash 分析デモ"""

    spreads: list[ExchangeSpread] = [
        {"exchange": "bitstamp", "best_bid": 108450.00, "best_ask": 108480.00,
         "spread_bps": 27.67, "liquidity_score": 85.3},
        {"exchange": "kraken", "best_bid": 108460.00, "best_ask": 108500.00,
         "spread_bps": 36.89, "liquidity_score": 92.1},
        {"exchange": "coinbase", "best_bid": 108470.00, "best_ask": 108495.00,
         "spread_bps": 23.06, "liquidity_score": 97.8},
        {"exchange": "binance", "best_bid": 108455.00, "best_ask": 108485.00,
         "spread_bps": 27.67, "liquidity_score": 99.2},
    ]

    api_key = os.getenv("HOLYSHEEP_API_KEY")
    if not api_key or api_key == "YOUR_HOLYSHEEP_API_KEY":
        print("[DEMO] HolySheep API キー未設定のため分析をスキップ")
        return

    analyzer = MultiExchangeAnalyzer(api_key)
    result = analyzer.rank_exchanges_by_spread(spreads)
    print("\n=== Gemini 2.5 Flash 分析結果 ===")
    print(result)

    # コスト表の出力
    print("\n=== HolySheep 月間コスト比較表（1,000万トークン/月）===")
    cost_table = analyzer.cost_estimate_table()
    for model, data in cost_table.items():
        print(f"\n{model}:")
        print(f"  公式月額費用: ¥{data['1Mtok_cost_official_jpy']:,.2f}")
        print(f"  HolySheep 月額費用: ¥{data['monthly_10M_cost_jpy']:,.2f}")
        print(f"  月間節約額: ¥{data['monthly_10M_savings_jpy']:,.2f} ({data['savings_pct']}%)")
        print(f"  レイテンシ: {data['latency']}")


if __name__ == "__main__":
    simulate_multi_exchange_comparison()

価格とROI：月間1,000万トークンでのコスト構造

暗号通貨データ分析において API コストは収益率に直結します。HolySheep AI を利用した場合の 月間1,000万トークン 使用時のコスト構造を以下に示します。2026年5月現在の Output 価格を採用しました。

モデル	公式 ($/MTok)	公式 月額費用 (¥)	HolySheep 月額費用 (¥)	月間節約額 (¥)	割引率	レイテンシ
GPT-4.1	$8.00	¥58,400	¥8,000	¥50,400	86.3%	<50ms
Claude Sonnet 4.5	$15.00	¥109,500	¥15,000	¥94,500	86.3%	<50ms
Gemini 2.5 Flash	$2.50	¥18,250	¥2,500	¥15,750	86.3%	<50ms
DeepSeek V3.2	$0.42	¥3,066	¥420	¥2,646	86.3%	<50ms

DeepSeek V3.2 は $0.42/MTok の最安値ながら、板情報の定性分析やシグナル判定には Gemini 2.5 Flash の $2.50/MTok がコスト対効果で優れています。私の実運用では、Orderbook の構造分析（DeepSeek V3.2 @ ¥0.42/MTok）とビジネス判断サマリー（Gemini 2.5 Flash @ ¥2.50/MTok）の二段構成を採用し、1,000万トークン/月 使用時に月額 ¥1,200 前後の API コストで運用できています。

向いている人・向いていない人

向いている人

• 暗号通貨アービトラージ戦略を検証中のトレーダー・研究者：Tardis Bitstamp 板から低遅延でデータを取得し、HolySheep の DeepSeek V3.2 でスプレッド分析を 低コストで繰り返したい人
• マルチ取引所 BOT を構築中の開発者：¥1=$1 レートで GPT-4.1・Claude Sonnet 4.5・Gemini 2.5 Flash・DeepSeek V3.2 をプロジェクトごとに切り替えて экспериментしたい人
• 日本語ベースの技術ドキュメントを好むチーム：WeChat Pay / Alipay で日本円換算額を直接支払い、手間なく API を プロビジョニングしたい人
• コスト最適化を重視するスタートアップ：API コストを86%削減し、その予算を取引手数料やインフラに再配分したい人

向いていない人

• 低遅延 WebSocket ストリーミング専用で構成を作りたい人：HolySheep は REST ベースのため、約50msのレイテンシが発生します。Tick-by-Tick の HFT には Tardis の 直接接続が必要です
• Anthropic/Google 公式 SDK の全機能（Projects, Workspaces, Cost管理）を必要とする人：HolySheep は標準 OpenAI 互換 API を 提供しており、公式 SDK の独自機能は利用できません
• 公式領収書・企業請求（請求書払い）が必要な人：HolySheep はWeChat Pay/Alipay/クレジットカード払いを想定しており、日本の企业所得税向け請求書払いは現在対応外です

HolySheepを選ぶ理由

暗号通貨市場データの分析基盤として HolySheep を選ぶ根拠は私の実体験に基づいています。2026年4月から Tardis Bitstamp 板データと HolySheep API を組み合わせた自動分析システム運用を開始し、以下の利点を実感しています：

• ¥1=$1 の為替レートによるコスト優位性：DeepSeek V3.2 ¥0.42/MTok × 月間500万トークン = 月額 ¥2,100 で運用しており、これが公式レート（¥7.3/$1）であれば ¥15,330 になります。年間 ¥158,760 の差額はこの分析システムの本稿で構築したように、追加 BOT 开发や服务器迁移に使用しています。
• <50ms レイテンシ：私の監視システム（ArbitrageMonitor）では Tardis API からのデータ取得が平均28ms、HolySheep LLM 分析が平均45msで完了しており、合計でも1秒以内に Orderbook → LLM分析 → DB保存のサイクルを回せています。
• WeChat Pay / Alipay 対応：日本の銀行汇款不要で、日本円建支出として 管理しやすい点は法人・個人共に大きな利点です。
• 統一エンドポイント https://api.holysheep.ai/v1：プロジェクトごとに異なる base_url を 管理する必要がなく、環境変数 HOLYSHEEP_API_KEY を1つだけ持つことで複数の 分析パイプラインを切り替えられます。

Step 3：アーカイブデータの分析ダッシュボード（Claude Sonnet 4.5 活用）

SQLite アーカイバに蓄積された Orderbook 快照と裁定シグナルを、Claude Sonnet 4.5（$15/MTok）を使って 月次サマリーとして 生成するユーティリティを実装します。Hol