Stablecoin Grid Trading: USDT/USDC Stratejisi ve Python Botu

Kripto piyasasında likidite park etmek tam bir karın ağrısıdır. BTC veya ETH tarafında dip beklerken stablecoin'leri spotta yatırmak, paranı enflasyona yedirmekten farksız. Lending protokollerine versen %2–4 APY gibi komik getiriler sunuyorlar, üstüne bir de akıllı sözleşme (smart contract) riski cabası.

USDT/USDC veya USDC/DAI gibi paritelerde spot Grid trade çalıştırarak, tamamen yatay (akümülasyon) giden piyasada bile %3–8 APR koparabilirsiniz. Kaldıraçsız, likidasyon riski olmadan ve "güvenli" yatay piyasada yıllık %50 vaat eden fenomen masallarına kapılmadan.

Bütün strateji tek bir gerçek üzerine kurulu: Stablecoin'ler hiçbir zaman tam olarak $1.0000 seviyesinde sabit durmaz. Protokoller arası sürekli fon geçişleri, arbitraj ve itibari paraya (fiat) çıkışlar nedeniyle USDT/USDC paritesi $0.9980–$1.0020 gibi dar bir bantta sürekli mekik dokur. Limit emir ağı (grid) ise bu mikro dalgalanmaların her birinden kârı toplar.

Komisyon Tuzağı: Acemilerin İlk Adımda Patladığı Yer

Stablecoin'lerde çalışan grid botlarının %90'ının zarar yazmasının ana sebebi Fee Drag, yani komisyon aşınmasıdır.

Şöyle düşünün: %0.01 adımlı bir grid kurdunuz (yani her $0.0001 seviyesine bir emir koydunuz). Borsadaki Maker komisyonunuz da standart %0.02 olsun. $0.9999'dan aldınız, $1.0000'dan sattınız. Kağıt üzerinde %0.01 kazandınız. Ama pratikte — girişte %0.02, çıkışta %0.02 ödediniz. Sonuç: Turlayan her işlemde net -%0.03 zarar.

Kulağınıza küpe yapın: Grid adımı (step), bir turdaki toplam komisyonun (Maker Buy + Maker Sell) en az 2.5–3 katı olmak zorundadır.

Buradan katı bir kural çıkıyor: Stablecoin'lerde Grid çalıştırmak sadece iki senaryoda mantıklıdır:

• USDT/USDC veya USDC/DAI paritelerinde borsanın Zero Fee (Sıfır Komisyon) kampanyası varsa (%0 Maker / %0 Taker).
• CEX üzerinde sıfır veya negatif (Rebate) Maker komisyonuna sahip sağlam bir VIP seviyeniz varsa.

İşin Gerçek Ekonomisi ve Grid Parametreleri

Spotta %30–50 APY gösteren hayali tabloları unutun. Tahta derinliği ve günlük volatiliteye göre piyasanın sunduğu reel rakamlar şunlardır:

Eğer birileri size saf spotta bundan daha yüksek getiri vaat ediyorsa, ya dolandırıcıdır ya da o paritede yakın zamanda sert bir de-peg (ipini koparma) riski vardır.

$10,000 Anapara Üzerinden Hesaplama Örneği

USDT/USDC paritesini ele alalım. Anlık fiyat tam $1.0000 olsun.

• Aralığı $0.9990 – $1.0010 olarak belirliyoruz (%0.2 genlik).
• Grid sayısı (Grids): 20 kademe.
• Grid adımı: ($1.0010 - $0.9990) / 20 = $0.0001 (%0.01).
• Kademe başına emir büyüklüğü: $10,000 / 20 = $500.
• 1 turdan (Buy + Sell) gelen brüt kâr: $500 * %0.01 = $0.05.

Normal bir volatilitede bot 24 saat içinde 60 ila 140 tur kapatır. Nakit karşılığı ise sıfır komisyonlu ortamda $10,000 kasadan günlük $3.0–$7.0 net kâr demektir. Yıllığa vurduğunuzda, paranızı ne idüğü belirsiz akıllı sözleşmelere kitlemeden %4–6 APR temiz gelir elde etmiş olursunuz.

Spot Grid İçin Hazır Python Botu

Aşağıdaki script WebSocket (ccxt.pro) üzerinden asenkron çalışır. Anlık tahtayı çeker, mevcut fiyata göre limit grid'i dizer, sonrasında gerçekleşen emirleri canlı dinleyip anında bir adım üstüne veya altına ters emri çakar.

import asyncio
import logging
from decimal import Decimal
import ccxt.pro as ccxt

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s'
)


class StableGridBot:
    def __init__(
        self,
        symbol: str,
        lower_price: float,
        upper_price: float,
        grids: int,
        amount_per_grid: float,
        api_key: str,
        api_secret: str
    ):
        self.symbol = symbol
        self.lower_price = Decimal(str(lower_price))
        self.upper_price = Decimal(str(upper_price))
        self.grids = grids
        self.amount_per_grid = amount_per_grid
        self.step = (self.upper_price - self.lower_price) / Decimal(str(grids))

        self.exchange = ccxt.binance({
            'apiKey': api_key,
            'secret': api_secret,
            'enableRateLimit': True,
            'options': {
                'defaultType': 'spot'
            }
        })

        self.active_orders = {}

    async def initialize_grid(self):
        await self.exchange.load_markets()

        market = self.exchange.market(self.symbol)

        min_cost = (
            market
            .get('limits', {})
            .get('cost', {})
            .get('min')
        )

        if min_cost:
            order_cost = (
                float(self.amount_per_grid)
                * float(self.lower_price)
            )

            if order_cost < min_cost:
                raise ValueError(
                    f"Order cost {order_cost} below minimum {min_cost}"
                )

        open_orders = await self.exchange.fetch_open_orders(
            self.symbol
        )

        existing_prices = set()

        if open_orders:
            logging.info(
                f"Found {len(open_orders)} open orders. "
                f"Restoring state from exchange..."
            )

            for order in open_orders:
                price_str = self.exchange.price_to_precision(
                    self.symbol,
                    order['price']
                )

                self.active_orders[order['id']] = (
                    order['side'],
                    float(price_str)
                )

                existing_prices.add(price_str)

        ticker = await self.exchange.fetch_ticker(
            self.symbol
        )

        current_price = Decimal(
            str(ticker['last'])
        )

        logging.info(
            f"Grid initialized. "
            f"Current price for {self.symbol}: {current_price}"
        )

        for i in range(self.grids + 1):

            raw_price = (
                self.lower_price +
                (Decimal(str(i)) * self.step)
            )

            price_str = self.exchange.price_to_precision(
                self.symbol,
                str(raw_price)
            )

            if price_str in existing_prices:
                continue

            price = float(price_str)

            if Decimal(price_str) < current_price:

                order = await self.place_order(
                    'buy',
                    price
                )

                if order:
                    self.active_orders[order['id']] = (
                        'buy',
                        price
                    )

            elif Decimal(price_str) > current_price:

                order = await self.place_order(
                    'sell',
                    price
                )

                if order:
                    self.active_orders[order['id']] = (
                        'sell',
                        price
                    )

    async def place_order(
        self,
        side: str,
        price: float
    ):
        try:
            precise_price = float(
                self.exchange.price_to_precision(
                    self.symbol,
                    price
                )
            )

            precise_amount = float(
                self.exchange.amount_to_precision(
                    self.symbol,
                    self.amount_per_grid
                )
            )

            order = await self.exchange.create_order(
                symbol=self.symbol,
                type='limit',
                side=side,
                amount=precise_amount,
                price=precise_price
            )

            logging.info(
                f"Placed {side.upper()} order at "
                f"{precise_price}"
            )

            return order

        except Exception as e:
            logging.error(
                f"Failed to place "
                f"{side} order at {price}: {e}"
            )

            return None

    async def handle_order_fill(
        self,
        filled_order
    ):
        order_id = filled_order['id']

        order_info = self.active_orders.pop(
            order_id,
            None
        )

        if order_info is None:
            return

        side, price = order_info

        logging.info(
            f"Filled {side.upper()} "
            f"order at price: {price}"
        )

        dec_price = Decimal(str(price))

        if side == 'buy':

            new_price_dec = dec_price + self.step

            if new_price_dec > self.upper_price:
                logging.info(
                    f"Skipping SELL order: "
                    f"{new_price_dec} is above "
                    f"upper grid boundary"
                )
                return

            new_price = float(
                self.exchange.price_to_precision(
                    self.symbol,
                    str(new_price_dec)
                )
            )

            new_order = await self.place_order(
                'sell',
                new_price
            )

            if new_order:
                self.active_orders[new_order['id']] = (
                    'sell',
                    new_price
                )

        else:

            new_price_dec = dec_price - self.step

            if new_price_dec < self.lower_price:
                logging.info(
                    f"Skipping BUY order: "
                    f"{new_price_dec} is below "
                    f"lower grid boundary"
                )
                return

            new_price = float(
                self.exchange.price_to_precision(
                    self.symbol,
                    str(new_price_dec)
                )
            )

            new_order = await self.place_order(
                'buy',
                new_price
            )

            if new_order:
                self.active_orders[new_order['id']] = (
                    'buy',
                    new_price
                )

    async def start(self):
        await self.initialize_grid()

        while True:
            try:
                orders = await self.exchange.watch_orders(
                    self.symbol
                )

                for order in orders:

                    if (
                        order.get('status') == 'closed'
                        and order.get('id') in self.active_orders
                    ):
                        await self.handle_order_fill(
                            order
                        )

            except Exception as e:
                logging.error(
                    f"WebSocket error: {e}"
                )

                await asyncio.sleep(5)

    async def close(self):
        try:
            await self.exchange.close()
        except Exception:
            pass


async def main():
    bot = StableGridBot(
        symbol='USDC/USDT',
        lower_price=0.9985,
        upper_price=1.0015,
        grids=30,
        amount_per_grid=500,
        api_key='YOUR_API_KEY',
        api_secret='YOUR_API_SECRET'
    )

    try:
        await bot.start()
    finally:
        await bot.close()


if __name__ == '__main__':
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logging.info(
            "Bot shut down by user"
        )

Kasayı Sıfırlayabilecek Tek Hakiki Risk

Stablecoin grid ticaretinde kaldıraç riski yoktur ama kaskat de-peg riski vardır.

Eğer paritedeki stablecoin'lerden biri dolara olan demirini koparıp $0.90'a doğru çakılmaya başlarsa, bot disiplinli bir şekilde düşen her bacağı bütün kasanızla toplamaya devam eder. Günün sonunda elinizde çöp olmuş tek bir varlıktan %100 oranında kalır.

Patlamamak için ne yapmalı:

• Katı Stop-Loss: Grid alt sınırının hemen altına acil durum stop-loss'u koyun. USDC/USDT paritesi için bu seviye $0.9940 civarıdır. Kasanın %0.5'ini stop etmek, patlak bir tokende 6 ay mahsur kalmaktan fersah fersah iyidir.
• Curve 3pool Takibi: DeFi havuzlarındaki dengesizlik, merkezi borsalardaki (CEX) dump'lardan her zaman önce haber verir. Curve tarafında stablecoin'lerden birinin payı %60–65 üzerine çıkıyorsa — botu anında fişten çekme vakti gelmiştir.
• Kaldıraçtan Uzak Durun: "Yüksek APY" sevdasıyla stablecoin'lerde 10x kaldıraçla grid açmaya kalkmak, rutin likidite park etme işini rulete çevirir; piyasadaki ufacık bir hıçkırıkta likidasyon gelir.

Bu üç kurala sadık kalın, borsa komisyonlarını sıkı takip edin ve aralığı çok geniş tutmayın — işte o zaman spot grid sizin için tıkır tıkır çalışan pasif bir nakit akışına dönüşür.