import ccxt

# ccxt.binance の future サンドボックスは廃止済み。
# 代わりに ccxt.binanceusdm（USD-M先物専用クラス）＋ set_sandbox_mode を使用する。
exchange = ccxt.binanceusdm({
    'apiKey': 'YOUR_DEMO_API_KEY',
    'secret': 'YOUR_DEMO_SECRET',
    'enableRateLimit': True,  # 絶対に外さない！
})

# デモトレードモードを有効化（旧テストネット/サンドボックスの代替）
exchange.set_sandbox_mode(True)

# 接続確認
balance = exchange.fetch_balance()
print(balance['USDT'])

# 注文作成テスト
# binanceusdm では USDM無期限先物のシンボルは 'BTC/USDT:USDT' 形式を使用する
order = exchange.create_order(
    symbol='BTC/USDT:USDT',
    type='limit',
    side='buy',
    amount=0.001,
    price=50000
)
print(f"注文ID: {order['id']}")

# 注文キャンセルテスト
exchange.cancel_order(order['id'], 'BTC/USDT:USDT')

# 残高確認テスト
balance = exchange.fetch_balance()
print(f"USDT残高: {balance['USDT']['free']}")

# オープン注文一覧確認
open_orders = exchange.fetch_open_orders('BTC/USDT:USDT')
print(f"未約定注文数: {len(open_orders)}")

pip install "ccxt[pro]"

import ccxt.pro as ccxtpro
import asyncio

async def watch_price():
    exchange = ccxtpro.binance({'enableRateLimit': True})

    try:
        while True:
            # リアルタイムでティッカーを受信
            ticker = await exchange.watch_ticker('BTC/USDT')
            price = ticker['last']
            print(f"BTC/USDT 現在価格: {price}")

            # ここでシグナル判定ロジックを呼ぶ
            signal = check_signal(price)
            if signal == 'BUY':
                order = await exchange.create_order(
                    'BTC/USDT', 'market', 'buy', 0.001
                )
                print(f"買い注文執行: {order['id']}")
    finally:
        await exchange.close()

def check_signal(price):
    # ここに戦略ロジックを入れる
    return None

asyncio.run(watch_price())

import ccxt.pro as ccxtpro
import asyncio
import pandas as pd
import numpy as np

def calculate_atr(ohlcv_data, period=14):
    """ATR（平均真のレンジ）を計算"""
    df = pd.DataFrame(
        ohlcv_data,
        columns=['timestamp', 'open', 'high', 'low', 'close', 'volume']
    )
    df['tr'] = np.maximum(
        df['high'] - df['low'],
        np.maximum(
            abs(df['high'] - df['close'].shift(1)),
            abs(df['low'] - df['close'].shift(1))
        )
    )
    return df['tr'].rolling(period).mean().iloc[-1]

async def live_trade_with_atr_stop():
    exchange = ccxtpro.binance({
        'apiKey': 'YOUR_API_KEY',
        'secret': 'YOUR_SECRET',
        'enableRateLimit': True,
    })
    exchange.set_sandbox_mode(True)  # テスト中は必ずサンドボックス！

    entry_price = None
    stop_loss_price = None

    try:
        while True:
            # OHLCVをリアルタイムで取得
            ohlcv = await exchange.watch_ohlcv('BTC/USDT', '1m')

            if len(ohlcv) >= 15:
                atr = calculate_atr(ohlcv[-50:])
                current_price = ohlcv[-1][4]  # 最新クローズ価格

                # エントリー済みの場合はストップロスチェック
                if entry_price is not None and stop_loss_price is not None:
                    if current_price <= stop_loss_price:
                        print(f"ストップロス発動！！ {current_price} <= {stop_loss_price}")
                        order = await exchange.create_order(
                            'BTC/USDT', 'market', 'sell', 0.001
                        )
                        entry_price = None
                        stop_loss_price = None
    finally:
        await exchange.close()

asyncio.run(live_trade_with_atr_stop())

import ccxt.pro as ccxtpro
import asyncio

async def fetch_multiple_pairs(exchange, symbols):
    """複数ペアのティッカーをバッチ取得（API呼び出し1回！）"""
    tickers = await exchange.fetch_tickers(symbols)
    return tickers

async def main():
    exchange = ccxtpro.binance({'enableRateLimit': True})
    exchange.set_sandbox_mode(True)

    symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT']

    try:
        tickers = await fetch_multiple_pairs(exchange, symbols)
        for symbol, ticker in tickers.items():
            print(f"{symbol}: 現在価格={ticker['last']}, 24h変化率={ticker['percentage']:.2f}%")
    finally:
        await exchange.close()

asyncio.run(main())

import ccxt.pro as ccxtpro
import asyncio

async def watch_single_pair(exchange, symbol, semaphore):
    """1ペアを監視するコルーチン"""
    while True:
        ticker = await exchange.watch_ticker(symbol)
        current_price = ticker['last']

        signal = check_signal(symbol, current_price)

        if signal == 'BUY':
            # セマフォで同時注文数を制御（複数ペアの残高競合を防ぐ）
            async with semaphore:
                order = await exchange.create_order(
                    symbol, 'market', 'buy', 0.001
                )
                print(f"[{symbol}] 買い注文: {order['id']}")

def check_signal(symbol, price):
    # ここに各ペアの戦略ロジックを実装
    return None

async def run_multi_pair_bot():
    exchange = ccxtpro.binance({
        'apiKey': 'YOUR_API_KEY',
        'secret': 'YOUR_SECRET',
        'enableRateLimit': True,
    })
    exchange.set_sandbox_mode(True)

    symbols = ['BTC/USDT', 'ETH/USDT', 'SOL/USDT', 'BNB/USDT']

    # セマフォで同時に実行できる注文数を2件に制限
    semaphore = asyncio.Semaphore(2)

    try:
        # 全ペアを並列で監視開始！！
        await asyncio.gather(
            *[watch_single_pair(exchange, symbol, semaphore) for symbol in symbols]
        )
    finally:
        await exchange.close()

asyncio.run(run_multi_pair_bot())

import ccxt.pro as ccxtpro
import asyncio

class MultiPairBot:
    def __init__(self, exchange, symbols, budget_per_pair=100):
        self.exchange = exchange
        self.symbols = symbols
        self.budget_per_pair = budget_per_pair  # 1ペアあたりの予算（USDT）
        self.positions = {symbol: None for symbol in symbols}  # ポジション管理
        self.semaphore = asyncio.Semaphore(2)

    async def get_available_budget(self):
        """利用可能残高を取得"""
        balance = await self.exchange.fetch_balance()
        return balance['USDT']['free']

    async def watch_and_trade(self, symbol):
        """1ペアの監視＋トレードループ"""
        while True:
            ticker = await self.exchange.watch_ticker(symbol)
            price = ticker['last']

            # ポジションなし → エントリー判断
            if self.positions[symbol] is None:
                signal = self.check_entry_signal(symbol, price)
                if signal == 'BUY':
                    budget = await self.get_available_budget()
                    if budget >= self.budget_per_pair:
                        async with self.semaphore:
                            amount = self.budget_per_pair / price
                            order = await self.exchange.create_order(
                                symbol, 'market', 'buy', amount
                            )
                            self.positions[symbol] = {
                                'entry_price': price,
                                'amount': amount,
                                'order_id': order['id']
                            }
                            print(f"[{symbol}] エントリー: {price} USDT")

            # ポジションあり → 決済判断
            else:
                pos = self.positions[symbol]
                if self.check_exit_signal(symbol, price, pos['entry_price']):
                    async with self.semaphore:
                        order = await self.exchange.create_order(
                            symbol, 'market', 'sell', pos['amount']
                        )
                        pnl = (price - pos['entry_price']) * pos['amount']
                        print(f"[{symbol}] 決済: {price} USDT | PnL: {pnl:.2f} USDT")
                        self.positions[symbol] = None

    def check_entry_signal(self, symbol, price):
        # エントリー判断ロジック（ここに戦略を実装）
        return None

    def check_exit_signal(self, symbol, price, entry_price):
        # 決済判断ロジック（例：2%利益確定 or 1%損切り）
        return_rate = (price - entry_price) / entry_price
        return return_rate >= 0.02 or return_rate <= -0.01

    async def run(self):
        try:
            await asyncio.gather(
                *[self.watch_and_trade(symbol) for symbol in self.symbols]
            )
        finally:
            await self.exchange.close()

import ccxt
import asyncio

async def safe_create_order(exchange, symbol, order_type, side, amount, max_retries=3):
    """エラーハンドリング付き注文作成（指数バックオフ）"""
    for attempt in range(max_retries):
        try:
            order = await exchange.create_order(symbol, order_type, side, amount)
            return order

        except ccxt.NetworkError as e:
            wait = 2 ** attempt  # 1秒 → 2秒 → 4秒と倍増
            print(f"ネットワークエラー（試行{attempt + 1}/{max_retries}）: {e}")
            print(f"{wait}秒後にリトライ……")
            await asyncio.sleep(wait)

        except ccxt.RateLimitExceeded as e:
            wait = 10 * (attempt + 1)
            print(f"レートリミット超過: {e} → {wait}秒待機")
            await asyncio.sleep(wait)

        except ccxt.InsufficientFunds as e:
            print(f"残高不足で注文キャンセル: {e}")
            return None  # リトライ不要

        except ccxt.BaseError as e:
            print(f"予期せぬCCXTエラー: {e}")
            if attempt == max_retries - 1:
                raise  # 最大試行回数を超えたら例外を再スロー
            await asyncio.sleep(2 ** attempt)

    return None

class CircuitBreaker:
    def __init__(self, initial_balance, max_drawdown_pct=0.10):
        """
        initial_balance: 初期残高（USDT）
        max_drawdown_pct: 許容最大ドローダウン率（デフォルト10%）
        """
        self.initial_balance = initial_balance
        self.max_drawdown_pct = max_drawdown_pct
        self.is_tripped = False

    def check(self, current_balance):
        """現在残高をチェックして、許容範囲を超えたら停止フラグを立てる"""
        drawdown = (self.initial_balance - current_balance) / self.initial_balance
        if drawdown >= self.max_drawdown_pct:
            self.is_tripped = True
            print(
                f"サーキットブレーカー発動！！ "
                f"ドローダウン {drawdown:.1%} が上限 {self.max_drawdown_pct:.1%} を超過"
            )
        return not self.is_tripped

import requests

BOT_TOKEN = 'YOUR_BOT_TOKEN'

url = f'https://api.telegram.org/bot{BOT_TOKEN}/getUpdates'
response = requests.get(url)
data = response.json()

# messages の中に chat.id が入ってるヨ
for result in data['result']:
    print(f"chat_id: {result['message']['chat']['id']}")

import requests
import asyncio

class TelegramNotifier:
    def __init__(self, bot_token, chat_id):
        self.bot_token = bot_token
        self.chat_id = chat_id
        self.base_url = f'https://api.telegram.org/bot{bot_token}/sendMessage'

    async def send(self, message):
        """非同期でTelegram通知を送信"""
        payload = {
            'chat_id': self.chat_id,
            'text': message,
            'parse_mode': 'HTML'
        }
        try:
            loop = asyncio.get_event_loop()
            await loop.run_in_executor(
                None,
                lambda: requests.post(self.base_url, data=payload, timeout=10)
            )
        except Exception as e:
            print(f"Telegram通知エラー（CCXTライブトレードは継続）: {e}")

async def notify_order(notifier, symbol, side, price, amount):
    msg = (
        f"<b>【CCXTライブトレード注文通知】</b>\n"
        f"通貨ペア: {symbol}\n"
        f"方向: {side.upper()}\n"
        f"価格: {price:.2f} USDT\n"
        f"数量: {amount:.4f}\n"
        f"約定金額: {price * amount:.2f} USDT"
    )
    await notifier.send(msg)

# SSHでEC2に接続したら、まず環境を整えるヨ！！
sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv git -y

# プロジェクトディレクトリを作成
mkdir ~/ccxt_bot && cd ~/ccxt_bot

# 仮想環境を作成・有効化
python3 -m venv venv
source venv/bin/activate

# 必要なライブラリをインストール
pip install "ccxt[pro]" pandas numpy requests python-dotenv

sudo nano /etc/systemd/system/ccxt_bot.service

[Unit]
Description=CCXT Live Trade Bot
After=network.target

[Service]
Type=simple
User=ubuntu
WorkingDirectory=/home/ubuntu/ccxt_bot
ExecStart=/home/ubuntu/ccxt_bot/venv/bin/python main.py
Restart=always
RestartSec=10
EnvironmentFile=/home/ubuntu/ccxt_bot/.env

[Install]
WantedBy=multi-user.target

# サービスを有効化して起動！！
sudo systemctl daemon-reload
sudo systemctl enable ccxt_bot
sudo systemctl start ccxt_bot

# 動作確認
sudo systemctl status ccxt_bot
sudo journalctl -u ccxt_bot -f  # ログをリアルタイムで確認

# .env ファイルの例
BINANCE_API_KEY=your_api_key_here
BINANCE_SECRET=your_secret_here
TELEGRAM_BOT_TOKEN=your_telegram_token
TELEGRAM_CHAT_ID=your_chat_id

import logging
import os
from datetime import datetime

def setup_logger(name='ccxt_bot', log_dir='logs'):
    """ファイルとコンソール両方に出力するロガーを設定"""
    os.makedirs(log_dir, exist_ok=True)

    log_file = os.path.join(
        log_dir, f"{datetime.now().strftime('%Y%m%d')}.log"
    )

    logger = logging.getLogger(name)
    logger.setLevel(logging.INFO)

    file_handler = logging.FileHandler(log_file, encoding='utf-8')
    file_handler.setLevel(logging.INFO)

    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)

    formatter = logging.Formatter(
        '%(asctime)s [%(levelname)s] %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)

    if not logger.handlers:
        logger.addHandler(file_handler)
        logger.addHandler(console_handler)

    return logger

logger = setup_logger()
logger.info("CCXTライブトレードボット起動！！")
logger.warning("残高が低下しています")
logger.error("APIエラーが発生しました")