Blockchain Kütüphanesi Kullanmadan Python ile Zincir Üzeri Uyarı Botu Nasıl Geliştirilir?

Blockchain Kütüphanesi Kullanmadan Python ile Zincir Üzeri Uyarı Botu Nasıl Geliştirilir?

Kripto para piyasalarında veya merkeziyetsiz uygulamalar (dApp) dünyasında yaşanan gelişmeleri anlık olarak takip etmek, çoğu zaman manuel yöntemlerle mümkün değildir. Fırsatları yakalamak, güvenlik ihlallerini önceden tespit etmek veya önemli cüzdan hareketlerini izlemek için otomatik sistemlere ihtiyaç duyarız. Peki, Python kullanarak ve hiçbir özel blockchain kütüphanesine bağımlı kalmadan, doğrudan zincir üzerindeki verileri çekip bize uyarı gönderecek bir botu nasıl geliştirebiliriz? Bu makalede, bu sorunun cevabını adım adım keşfedecek, temelden başlayarak ileri seviye uygulamalara kadar uzanan bir yolculuğa çıkacağız.

Zincir Üzeri Olayları Takip Etmek Neden Önemli?

Blockchain teknolojisi, şeffaflık ve değişmezlik gibi temel özellikleriyle finans, tedarik zinciri ve birçok farklı sektörde devrim niteliğinde yenilikler sunuyor. Ancak bu şeffaflık, aynı zamanda devasa bir veri akışını da beraberinde getiriyor. Her saniye milyarlarca işlem gerçekleşiyor, yeni bloklar oluşuyor ve akıllı sözleşmeler etkileşime giriyor. Bu bilgi okyanusunda, kişisel veya kurumsal stratejilerimiz için kritik olabilecek belirli olayları manuel olarak izlemek neredeyse imkansızdır. İşte bu noktada, otomatik uyarı botları devreye girer ve bize paha biçilmez bir avantaj sağlar.

Özellikle hızlı hareket eden kripto piyasalarında, anlık bilgiye erişim, yatırım kararları için hayati önem taşır. Örneğin, büyük bir cüzdanın (balina) önemli miktarda token transferi yapması, piyasada dalgalanmalara yol açabilir. Bir merkeziyetsiz finans (DeFi) protokolündeki likidite havuzunda beklenmedik bir değişiklik, arbitraj fırsatları yaratabilir. Veya bir akıllı sözleşmede kritik bir güvenlik açığının tetiklenmesi, fon kaybına neden olabilir. Bu tür senaryolarda, olaylar henüz çok tazeyken bilgi sahibi olmak, proaktif adımlar atmamızı sağlar. Geleneksel yöntemlerle bu verileri sürekli taramak hem zaman alıcı hem de yorucudur. Bir uyarı botu, bu görevi üstlenerek bize zaman kazandırır ve önemli gelişmeleri kaçırma riskimizi minimize eder. Bu otomasyon sayesinde, piyasa dinamiklerine daha hızlı adapte olabilir, potansiyel riskleri erken fark edebilir ve fırsatları değerlendirebiliriz.

Peki, neden özellikle Python ve neden “blockchain kütüphanesi kullanmadan”? Python, veri işleme, ağ istekleri ve otomasyon konularında oldukça güçlü ve esnek bir dildir. Geniş kütüphane ekosistemi ve okunabilir sözdizimi sayesinde, karmaşık görevleri bile nispeten kolayca gerçekleştirebiliriz. Blockchain kütüphaneleri (örneğin web3.py), genellikle alt seviye detayları soyutlayarak geliştirme sürecini hızlandırır. Ancak, bu kütüphaneler bazen gereksiz bağımlılıklar getirebilir, performansı düşürebilir veya belirli zincirler için kısıtlı destek sunabilir. Kütüphane kullanmadan doğrudan RPC (Remote Procedure Call) arayüzleriyle etkileşim kurmak, bize hem daha derin bir anlayış kazandırır hem de botumuz üzerinde tam kontrol sağlar. Bu yaklaşım, botumuzu daha hafif, daha esnek ve farklı EVM (Ethereum Sanal Makinesi) uyumlu zincirlere kolayca adapte edilebilir hale getirir. Ayrıca, bu yöntemle, blockchain’in temel işleyiş mekanizmalarını daha iyi kavrar ve veri akışını en temel seviyeden yönetme becerisi kazanırız. Bu makale boyunca, bu avantajları kullanarak nasıl güçlü bir uyarı botu inşa edeceğimizi adım adım göstereceğiz.

Blockchain Verilerine Doğrudan Erişim: Neden ve Nasıl?

Blockchain ağları, merkeziyetsiz yapıları gereği, verileri doğrudan bir veritabanından çekme imkanı sunmazlar. Bunun yerine, ağdaki her katılımcı (node), ağın tüm geçmişini içeren bir kopyayı saklar ve bu verilere erişim için belirli arayüzler sunar. Blockchain kütüphaneleri kullanmadan bir uyarı botu geliştirmek istediğimizde, bu arayüzleri doğrudan kullanmamız gerekir. Bu yaklaşım, bize hem esneklik hem de ağın temel işleyiş mekanizmalarını daha derinlemesine anlama fırsatı sunar.

Blockchain Node’ları ve RPC Arayüzleri Nedir?

Bir blockchain ağı, birbirine bağlı bilgisayarların (node’lar) bir koleksiyonudur. Her node, ağdaki tüm işlemleri ve blokları doğrular, saklar ve diğer node’larla paylaşır. Bu node’lar, ağın omurgasını oluşturur ve blockchain’in güvenliğini ve bütünlüğünü sağlar. Verilere erişmek veya ağ ile etkileşim kurmak için, bir node’a bağlanmamız gerekir. İşte bu noktada RPC (Remote Procedure Call) arayüzleri devreye girer. RPC, bir programın başka bir adresteki (genellikle bir ağdaki başka bir bilgisayardaki) bir programda bir prosedürü (fonksiyonu) çalıştırmasına olanak tanıyan bir protokoldür. Blockchain bağlamında, bu genellikle HTTP veya WebSockets üzerinden JSON-RPC standardı kullanılarak yapılır.

JSON-RPC, hafif ve durumsuz bir RPC protokolüdür. İstemciler (bizim botumuz gibi), belirli bir metodun adını ve ilgili parametreleri içeren JSON formatında bir istek gönderirler. Node, bu isteği işler ve yine JSON formatında bir yanıt döndürür. Örneğin, Ethereum ağında, eth_blockNumber metodu, ağdaki en son bloğun numarasını döndürürken, eth_getBlockByNumber metodu, belirli bir blok numarasının tüm detaylarını (içindeki işlemler dahil) sağlar. Bu metodlar aracılığıyla, blok zincirindeki her türlü veriye programatik olarak erişebiliriz. Kendi node’umuzu çalıştırmak yerine, Infura, Alchemy, QuickNode gibi üçüncü taraf RPC sağlayıcılarını kullanabiliriz. Bu servisler, yüksek performanslı ve güvenilir node’lara erişim sağlayarak kendi node’umuzu kurma ve yönetme yükünü ortadan kaldırır. Ancak bu servislerin de hız sınırlamaları (rate limiting) ve kullanım limitleri olabileceğini unutmamak gerekir.

İşlem (Transaction) ve Blok (Block) Yapısı

Blockchain’in temel yapı taşları, işlemler ve bloklardır. Bir işlem, ağdaki bir varlık transferini (örneğin Ether gönderimi) veya bir akıllı sözleşme ile etkileşimi temsil eder. Her işlem, gönderici adresi, alıcı adresi, gönderilen miktar (değer), işlem ücreti (gas), veri (data) ve bir işlem hash’i gibi bilgileri içerir. İşlem hash’i, işlemin benzersiz bir tanımlayıcısıdır ve blockchain üzerinde o işlemi bulmak için kullanılır. Akıllı sözleşme etkileşimlerinde, data alanı, çağrılan fonksiyonu ve fonksiyon parametrelerini içerir.

Bloklar ise, belirli bir süre içinde onaylanmış ve doğrulanmış bir grup işlemi bir araya getiren veri paketleridir. Her blok, bir önceki bloğun hash’ini (böylece zincirleme bir yapı oluşur), kendi benzersiz hash’ini, bir zaman damgasını, madenci ödülünü, zorluk seviyesini ve içinde barındırdığı tüm işlemlerin bir listesini içerir. Blok numarası, bir bloğun zincirdeki konumunu belirtir. Bizim uyarı botumuz, genellikle yeni oluşan blokları ve bu blokların içindeki işlemleri tarayarak çalışır. Belirli bir adrese gönderilen Ether transferlerini, bir akıllı sözleşmenin belirli bir fonksiyon çağrısını veya bir olayın (event) tetiklenmesini izlemek için blok ve işlem verilerini detaylı bir şekilde incelememiz gerekecektir. Bu verileri doğru bir şekilde analiz etmek, botumuzun etkinliğini doğrudan etkileyecektir. Örneğin, bir bloktan tüm işlemleri çektikten sonra, her bir işlemin to, from ve value alanlarını kontrol ederek ilgilendiğimiz kriterlere uyup uymadığını belirleyebiliriz. Bu ham verilere doğrudan erişim, bize filtreleme ve analiz süreçlerinde tam kontrol sağlar.

Gerekli Araçlar: Python ve İstek Kütüphaneleri

Python ile blockchain node’ları arasında iletişim kurmak için temel olarak iki şeye ihtiyacımız olacak: HTTP istekleri yapabilen bir kütüphane ve JSON verilerini işleyebilen bir mekanizma. Python’ın standart kütüphanesi bu yeteneklerin çoğunu zaten sunar, ancak daha kolay ve güçlü bir kullanım için üçüncü taraf kütüphanelerden yararlanabiliriz.

requests kütüphanesi, Python’da HTTP istekleri yapmak için de facto (fiili) standarttır. Kullanımı son derece basittir ve POST istekleri, başlık yönetimi, JSON veri gönderimi gibi tüm ihtiyaçlarımızı karşılar. Blockchain RPC çağrıları genellikle HTTP POST metodunu ve JSON formatında bir gövdeyi (body) kullanır. requests kütüphanesi, bu tür istekleri oluşturmayı ve yanıtları işlemeyi çok kolaylaştırır. Örneğin, bir JSON yükünü doğrudan json parametresi ile gönderebiliriz ve yanıtı da response.json() ile kolayca Python sözlüğüne dönüştürebiliriz.

JSON verilerini Python’da işlemek için ise, Python’ın yerleşik json modülü fazlasıyla yeterlidir. RPC yanıtları genellikle JSON formatında gelir ve bu modül sayesinde bu verileri Python sözlüklerine veya listelerine dönüştürerek kolayca erişebilir ve filtreleyebiliriz. Örneğin, bir bloktan çekilen işlemler listesi, Python’da bir liste içinde sözlükler olarak temsil edilecek ve bu sayede belirli anahtarlara (örneğin 'to' veya 'value') göre filtreleme yapabileceğiz. Bu temel araçlarla, karmaşık blockchain verilerini bile sorunsuz bir şekilde çekip işleyebiliriz.

Adım Adım Geliştirme: Zincir Verilerini Çekme ve İşleme

Artık temel kavramları anladığımıza göre, Python ile bir blockchain node’una nasıl bağlanacağımızı ve veri çekeceğimizi adım adım görelim. Bu bölümde, botumuzun veri toplama çekirdeğini oluşturacağız.

RPC Bağlantısı Nasıl Kurulur?

Blockchain verilerine erişmek için öncelikle bir RPC (Remote Procedure Call) endpoint’ine ihtiyacımız var. Kendi Ethereum node’unuzu çalıştırmak yerine, genellikle Infura, Alchemy, QuickNode gibi servis sağlayıcılarını kullanmak daha pratik ve hızlıdır. Bu servisler, yüksek erişilebilirliğe sahip, ölçeklenebilir ve yönetilen node’lar sunar. Bir hesap oluşturarak ücretsiz veya ücretli bir plan dahilinde bir API anahtarı alabilir ve bu anahtar ile bir endpoint URL’i elde edebilirsiniz. Örneğin, Infura’dan alacağınız bir endpoint URL’i şöyle görünebilir: https://mainnet.infura.io/v3/YOUR_API_KEY.

Bu URL’i kullanarak bir HTTP POST isteği göndereceğiz. İstek gövdesi (body), JSON-RPC standardına uygun olmalıdır. Bu, genellikle jsonrpc sürümünü (genellikle “2.0”), çağrılacak metodun adını (method), metoda iletilecek parametreleri (params) ve bir istek kimliğini (id) içeren bir JSON nesnesidir. İşte Python’da requests kütüphanesi ile nasıl bir RPC bağlantısı kuracağımıza dair bir örnek:

import requests
import json

# RPC endpoint URL'iniz. Kendi Infura/Alchemy anahtarınızla değiştirin.
RPC_URL = "https://mainnet.infura.io/v3/YOUR_API_KEY"

def make_rpc_call(method, params=[]):
    headers = {"Content-Type": "application/json"}
    payload = {
        "jsonrpc": "2.0",
        "method": method,
        "params": params,
        "id": 1  # İstek kimliği, genellikle sabit bir değer olabilir
    }
    try:
        response = requests.post(RPC_URL, headers=headers, json=payload)
        response.raise_for_status()  # HTTP hataları için istisna fırlatır
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"RPC çağrısı sırasında hata oluştu: {e}")
        return None

# Örnek kullanım: Son blok numarasını çekme
# latest_block_number_response = make_rpc_call("eth_blockNumber")
# if latest_block_number_response:
#    print(f"Son blok numarası: {latest_block_number_response['result']}")
  

Yukarıdaki make_rpc_call fonksiyonu, herhangi bir JSON-RPC metodunu çağırmak için genel bir yapıdır. method parametresi çağrılacak RPC metodunu (örneğin eth_blockNumber), params ise bu metoda iletilecek argümanları alır. Yanıt olarak gelen JSON objesini response.json() ile Python sözlüğüne dönüştürüyoruz. Bu temel fonksiyon, botumuzun tüm RPC etkileşimleri için temelini oluşturacaktır. Bağlantı hatalarını yönetmek için try-except bloğunu kullanmak, botunuzun daha sağlam çalışmasını sağlar.

Son Bloğu ve İşlemleri Çekme

Uyarı botumuzun sürekli olarak yeni olayları izleyebilmesi için, blockchain’deki en son bloğu ve bu bloğun içindeki işlemleri düzenli olarak kontrol etmesi gerekir. Bu işlem iki adımdan oluşur: önce en son blok numarasını almak, ardından bu blok numarasını kullanarak bloğun tüm detaylarını çekmek. Ethereum ağında bu işlemler için eth_blockNumber ve eth_getBlockByNumber RPC metodlarını kullanırız.

eth_blockNumber metodu, ağdaki en son bloğun onaltılık (hexadecimal) formatındaki numarasını döndürür. Bu numarayı aldıktan sonra, eth_getBlockByNumber metoduna parametre olarak ileterek ilgili bloğun tüm verilerini (işlemler dahil) alabiliriz. eth_getBlockByNumber metodunun ikinci parametresi, işlemlerin tam detaylarıyla birlikte mi yoksa sadece işlem hash’leriyle mi döndürüleceğini belirler (true tam detaylar için). Bizim durumumuzda, işlemleri filtreleyeceğimiz için tam detaylara ihtiyacımız olacak.

def get_latest_block_number():
    response = make_rpc_call("eth_blockNumber")
    if response and 'result' in response:
        # Hexadecimal blok numarasını ondalık sayıya çeviriyoruz
        return int(response['result'], 16)
    return None

def get_block_details(block_number):
    # Blok numarasını onaltılık formata çeviriyoruz
    hex_block_number = hex(block_number)
    # eth_getBlockByNumber metodu, ikinci parametre olarak true alırsa
    # işlemlerin tam detaylarını döndürür, aksi takdirde sadece hash'lerini.
    response = make_rpc_call("eth_getBlockByNumber", [hex_block_number, True])
    if response and 'result' in response:
        return response['result']
    return None

# Örnek kullanım
# latest_num = get_latest_block_number()
# if latest_num:
#    print(f"En son blok numarası: {latest_num}")
#    block_details = get_block_details(latest_num)
#    if block_details:
#        print(f"Blok {latest_num} içindeki işlem sayısı: {len(block_details['transactions'])}")
#        # İlk işlemin detaylarını yazdır
#        if block_details['transactions']:
#            print(f"İlk işlem hash'i: {block_details['transactions'][0]['hash']}")
#            print(f"İlk işlem gönderici: {block_details['transactions'][0]['from']}")
#            print(f"İlk işlem alıcı: {block_details['transactions'][0]['to']}")
#            # Value onaltılık formatta gelir, wei cinsindendir.
#            value_wei = int(block_details['transactions'][0]['value'], 16)
#            value_eth = value_wei / (10**18) # Wei'den Ether'e çevirme
#            print(f"İlk işlem değeri: {value_eth} ETH")
  

Yukarıdaki kodda, get_latest_block_number fonksiyonu en son blok numarasını alıp ondalık sayıya çevirirken, get_block_details fonksiyonu bu numara ile bloğun tüm detaylarını çeker. Özellikle value alanı gibi sayısal değerler, RPC yanıtlarında onaltılık (hexadecimal) string olarak gelir. Bu değerleri Python’da kullanabilmek için int(value_str, 16) ile ondalık sayıya çevirmemiz gerekir. Ether miktarlarını işlerken, değerin genellikle Wei cinsinden (Ether’in en küçük birimi, 1 Ether = 10^18 Wei) geldiğini unutmamalı ve uygun dönüşümleri yapmalıyız. Bu fonksiyonlar, botumuzun her döngüde yeni blokları taramasını sağlayacak temel mekanizmayı oluşturur.

Belirli İşlemleri Filtreleme ve İzleme

Tüm bloktaki işlemleri çekmek güzel, ancak genellikle ilgilendiğimiz belirli kriterlere uyan işlemleri bulmak isteriz. Bu, botumuzun asıl amacını oluşturur. İşlemleri filtrelemek için, her işlemin from (gönderici), to (alıcı) adresleri, value (gönderilen miktar) ve input (işlem verisi) alanlarını inceleyebiliriz. Örneğin, belirli bir cüzdan adresine yapılan tüm transferleri veya belirli bir miktarın üzerindeki transferleri izlemek isteyebiliriz.

Aşağıdaki örnek, belirli bir hedef adrese yapılan ETH transferlerini nasıl filtreleyeceğimizi gösteriyor. Ayrıca, belirli bir minimum transfer miktarını da filtreleme kriteri olarak ekleyebiliriz. Bu, “balina” hareketlerini veya büyük fon transferlerini izlemek için çok kullanışlıdır.

def filter_transactions(transactions, target_address=None, min_value_eth=0):
    filtered_txs = []
    for tx in transactions:
        # 'to' alanı null olabilir (örneğin, sözleşme dağıtımı işlemleri için)
        if tx.get('to') and tx['to'].lower() == target_address.lower():
            # İşlem değerini Wei'den Ether'e çevir
            value_wei = int(tx['value'], 16)
            value_eth = value_wei / (10**18)

            if value_eth >= min_value_eth:
                filtered_txs.append({
                    "hash": tx['hash'],
                    "from": tx['from'],
                    "to": tx['to'],
                    "value_eth": value_eth,
                    "gas_price": int(tx['gasPrice'], 16) / (10**9), # Gwei
                    "gas_used": int(tx['gas'], 16) # Max gas
                })
    return filtered_txs

# Örnek kullanım: Binance sıcak cüzdanlarından birini izleyelim (örnek adres)
# Gerçek bir Binance sıcak cüzdanı adresi kullanın veya kendi adresinizi.
# Bu adres sadece örnek amaçlıdır.
TARGET_WALLET_ADDRESS = "0x28C6c06298d514Db089934071355E5743bf21d60" # Örnek bir adres
MIN_TRANSFER_AMOUNT_ETH = 100 # Sadece 100 ETH ve üzeri transferleri izle

# latest_num = get_latest_block_number()
# if latest_num:
#    block_details = get_block_details(latest_num)
#    if block_details:
#        important_transactions = filter_transactions(
#            block_details['transactions'],
#            target_address=TARGET_WALLET_ADDRESS,
#            min_value_eth=MIN_TRANSFER_AMOUNT_ETH
#        )
#        if important_transactions:
#            print(f"Blok {latest_num} içinde {TARGET_WALLET_ADDRESS} adresine/adresinden {MIN_TRANSFER_AMOUNT_ETH} ETH üzeri transferler:")
#            for tx in important_transactions:
#                print(f"  Hash: {tx['hash']}, Değer: {tx['value_eth']} ETH")
#        else:
#            print(f"Blok {latest_num} içinde belirlenen kriterlere uyan işlem bulunamadı.")
  

filter_transactions fonksiyonu, bir bloktaki tüm işlemleri alır ve belirtilen hedef adres ile minimum ETH miktarına göre filtreler. tx.get('to') kullanımı, to alanı olmayan işlemlerin (örneğin akıllı sözleşme dağıtımları) hataya yol açmasını engeller. Adres karşılaştırmalarını yaparken, büyük/küçük harf duyarlılığını ortadan kaldırmak için .lower() kullanmak iyi bir uygulamadır, zira Ethereum adresleri büyük/küçük harf duyarlı değildir. Bu filtreleme mantığı, botumuzun sadece gerçekten önemli olan olaylara odaklanmasını sağlar ve gereksiz bildirimlerin önüne geçer. Bu sayede, botumuz daha verimli çalışır ve bize sadece ilgili bilgileri sunar.

Uyarı Mekanizması Oluşturma: Bildirimleri Nasıl Göndeririz?

Botumuzun zincir üzerindeki verileri çekip filtrelemesi harika, ancak bu bilgileri bize ulaştırmadığı sürece bir anlam ifade etmez. Bu bölümde, botumuzun tespit ettiği önemli olayları bize bildirecek uyarı mekanizmalarını nasıl entegre edeceğimizi inceleyeceğiz. Telegram, anlık bildirimler için popüler ve kullanımı kolay bir platformdur.

Farklı Bildirim Kanalları Nelerdir?

Uyarıları göndermek için birçok farklı kanal kullanabiliriz. Seçim, kişisel tercihlerinize ve botunuzun hedef kitlesine bağlıdır:

• Telegram: Anlık mesajlaşma uygulaması olarak, botlar aracılığıyla hızlı ve etkili bildirimler göndermek için idealdir. Python için doğrudan Telegram Bot API’si ile etkileşim kurabiliriz.
• Discord: Özellikle oyun ve kripto topluluklarında yaygın olarak kullanılan Discord, webhook’lar aracılığıyla kolayca bildirim gönderme imkanı sunar.
• E-posta: Daha geleneksel bir yöntem olsa da, önemli ve acil olmayan bildirimler için hala geçerlidir. Python’ın smtplib modülü ile e-posta göndermek mümkündür.
• SMS: Gerçekten kritik uyarılar için SMS, yüksek erişilebilirliği nedeniyle tercih edilebilir. Üçüncü taraf SMS ağ geçitleri (Twilio gibi) aracılığıyla entegre edilebilir.
• Slack: İş ve ekip iletişimi için kullanılan Slack, webhook’lar veya bot API’si aracılığıyla bildirimler için uygun bir platformdur.

Bu makalede, hızlı kurulumu ve geniş kullanıcı tabanı nedeniyle Telegram’a odaklanacağız. Ancak temel mantık, diğer platformlar için de benzerdir; sadece API etkileşimleri farklılık gösterecektir.

Telegram Botu ile Entegrasyon

Telegram ile bildirim göndermek için öncelikle bir Telegram botu oluşturmanız gerekir. Bu işlem oldukça basittir:

1. Telegram uygulamasında @BotFather ile sohbet başlatın.
2. /newbot komutunu gönderin ve botunuza bir isim verin (örneğin “KriptoUyarıBotu”).
3. BotFather size bir API token’ı verecektir (örneğin 123456:ABC-DEF1234ghIkl-7890). Bu token’ı güvenli bir yerde saklayın, çünkü botunuzun kimliğidir.
4. Botunuzun size mesaj gönderebilmesi için, botunuza bir mesaj göndermeniz ve botunuzun chat ID’nizi bilmesi gerekir. Botunuza herhangi bir mesaj gönderdikten sonra, https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates adresine giderek (YOUR_BOT_TOKEN yerine kendi bot token’ınızı yazın) JSON çıktısında "chat":{"id":YOUR_CHAT_ID,"first_name":"YourName"} kısmındaki YOUR_CHAT_ID değerini bulabilirsiniz.

Bot token’ı ve chat ID’nizi aldıktan sonra, Python’da requests kütüphanesini kullanarak Telegram API’sine mesaj gönderebiliriz:

TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN" # BotFather'dan aldığınız token
TELEGRAM_CHAT_ID = "YOUR_TELEGRAM_CHAT_ID"     # Kendi chat ID'niz

def send_telegram_message(message):
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    payload = {
        "chat_id": TELEGRAM_CHAT_ID,
        "text": message,
        "parse_mode": "HTML" # Mesajı HTML olarak formatlayabiliriz
    }
    try:
        response = requests.post(url, json=payload)
        response.raise_for_status()
        print("Telegram mesajı başarıyla gönderildi.")
    except requests.exceptions.RequestException as e:
        print(f"Telegram mesajı gönderilirken hata oluştu: {e}")

# Örnek kullanım:
# send_telegram_message("Merhaba, bu bir test mesajıdır!")
# send_telegram_message("Yeni bir işlem tespit edildi!
Hash: 0x123...abc")
  

send_telegram_message fonksiyonu, aldığı mesajı Telegram API’sine POST isteği olarak gönderir. parse_mode="HTML" parametresi sayesinde, mesaj metninde HTML etiketleri (,
vb.) kullanarak mesajı daha okunaklı ve bilgilendirici hale getirebiliriz. Bu fonksiyon, botumuzun zincir üzerindeki önemli olayları bize anında bildirmesini sağlayacaktır.

import time

# Daha önceki fonksiyonlarımızı (make_rpc_call, get_latest_block_number, get_block_details, filter_transactions, send_telegram_message) buraya veya ayrı bir dosyadan import edebiliriz.

# Global değişken olarak son işlenen blok numarasını tutalım
last_processed_block = None

def start_alert_bot():
    global last_processed_block
    print("Uyarı botu başlatılıyor...")

    # Başlangıçta son blok numarasını al
    initial_block = get_latest_block_number()
    if initial_block:
        last_processed_block = initial_block
        print(f"Bot, {last_processed_block} numaralı bloktan itibaren izlemeye başlayacak.")
    else:
        print("Başlangıç blok numarasını alamadı, bot başlatılamıyor.")
        return

    while True:
        try:
            current_block_number = get_latest_block_number()
            if current_block_number is None:
                print("Mevcut blok numarasını alamadı, tekrar deniyor...")
                time.sleep(10) # Hata durumunda bekle
                continue

            if current_block_number > last_processed_block:
                print(f"Yeni bloklar tespit edildi: {last_processed_block + 1} - {current_block_number}")
                for block_num_to_process in range(last_processed_block + 1, current_block_number + 1):
                    block_details = get_block_details(block_num_to_process)
                    if block_details and 'transactions' in block_details:
                        print(f"Blok {block_num_to_process} işleniyor...")
                        important_transactions = filter_transactions(
                            block_details['transactions'],
                            target_address=TARGET_WALLET_ADDRESS,
                            min_value_eth=MIN_TRANSFER_AMOUNT_ETH
                        )
                        if important_transactions:
                            for tx in important_transactions:
                                message = (
                                    f"🚨 Yeni İşlem Uyarısı!\n"
                                    f"Zincir: Ethereum Mainnet\n"
                                    f"Blok: {block_num_to_process}\n"
                                    f"Hash: {tx['hash'][:10]}...\n"
                                    f"Gönderen: {tx['from'][:10]}...\n"
                                    f"Alıcı: {tx['to'][:10]}...\n"
                                    f"Miktar: {tx['value_eth']:.4f} ETH\n"
                                    f"Gas Ücreti: {tx['gas_price'] * tx['gas_used'] / (109 * 109):.6f} ETH (yaklaşık)"
                                )
                                send_telegram_message(message)
                                time.sleep(1) # API hız sınırlamalarına takılmamak için küçük bir bekleme
                    last_processed_block = block_num_to_process
            else:
                print(f"Yeni blok yok. Son blok: {current_block_number}. Bekleniyor...")

            time.sleep(30) # Her 30 saniyede bir kontrol et
        except Exception as e:
            print(f"Ana döngüde beklenmedik bir hata oluştu: {e}")
            time.sleep(60) # Hata durumunda daha uzun bekle

# Botu başlatmak için:
# if __name__ == "__main__":
#    start_alert_bot()
  

# İzlemek istediğimiz balina cüzdanı adresi (örnek adres, gerçek bir balina adresiyle değiştirin)
# Bu adres sadece örnek amaçlıdır.
BALINA_CUZDAN_ADRESI = "0xde0B295669a9FD93d5F28D9EeLnB38B008dC0d1" # Örnek bir balina adresi
MIN_BALINA_TRANSFER_ETH = 500 # Sadece 500 ETH ve üzeri transferleri izle

def filter_balina_transactions(transactions, balina_address, min_value_eth):
    """
    Belirli bir balina adresinden yapılan, belirli bir miktarın üzerindeki çıkış işlemlerini filtreler.
    """
    filtered_txs = []
    for tx in transactions:
        # İşlemin göndericisi balina adresi mi?
        if tx.get('from') and tx['from'].lower() == balina_address.lower():
            # İşlem değerini Wei'den Ether'e çevir
            value_wei = int(tx['value'], 16)
            value_eth = value_wei / (10**18)

            # Belirlenen minimum miktardan büyük mü?
            if value_eth >= min_value_eth:
                filtered_txs.append({
                    "hash": tx['hash'],
                    "from": tx['from'],
                    "to": tx['to'],
                    "value_eth": value_eth,
                    "gas_price": int(tx['gasPrice'], 16) / (10**9), # Gwei
                    "gas_used": int(tx['gas'], 16) # Max gas
                })
    return filtered_txs
  

# ... (önceki make_rpc_call, get_latest_block_number, get_block_details, send_telegram_message fonksiyonları ve global değişkenler) ...

# Global değişken olarak son işlenen blok numarasını tutalım
last_processed_block = None

def start_balina_alert_bot():
    global last_processed_block
    print("Balina uyarı botu başlatılıyor...")

    initial_block = get_latest_block_number()
    if initial_block:
        last_processed_block = initial_block
        print(f"Bot, {last_processed_block} numaralı bloktan itibaren izlemeye başlayacak.")
    else:
        print("Başlangıç blok numarasını alamadı, bot başlatılamıyor.")
        return

    while True:
        try:
            current_block_number = get_latest_block_number()
            if current_block_number is None:
                print("Mevcut blok numarasını alamadı, tekrar deniyor...")
                time.sleep(10)
                continue

            if current_block_number > last_processed_block:
                print(f"Yeni bloklar tespit edildi: {last_processed_block + 1} - {current_block_number}")
                for block_num_to_process in range(last_processed_block + 1, current_block_number + 1):
                    block_details = get_block_details(block_num_to_process)
                    if block_details and 'transactions' in block_details:
                        print(f"Blok {block_num_to_process} işleniyor...")
                        important_transactions = filter_balina_transactions(
                            block_details['transactions'],
                            balina_address=BALINA_CUZDAN_ADRESI,
                            min_value_eth=MIN_BALINA_TRANSFER_ETH
                        )
                        if important_transactions:
                            for tx in important_transactions:
                                message = (
                                    f"🐳 BALINA UYARISI! 🐳\n"
                                    f"Zincir: Ethereum Mainnet\n"
                                    f"Blok: {block_num_to_process}\n"
                                    f"Hash: {tx['hash'][:10]}...\n"
                                    f"Gönderen (Balina): {tx['from'][:10]}...\n"
                                    f"Alıcı: {tx['to'][:10]}...\n"
                                    f"Miktar: {tx['value_eth']:.4f} ETH\n"
                                    f"Gas Ücreti: {tx['gas_price'] * tx['gas_used'] / (109 * 109):.6f} ETH (yaklaşık)"
                                )
                                send_telegram_message(message)
                                time.sleep(1)
                    last_processed_block = block_num_to_process
            else:
                print(f"Yeni blok yok. Son blok: {current_block_number}. Bekleniyor...")

            time.sleep(30)
        except Exception as e:
            print(f"Ana döngüde beklenmedik bir hata oluştu: {e}")
            time.sleep(60)

# Botu başlatmak için:
# if __name__ == "__main__":
#    start_balina_alert_bot()
  

# Örnek ERC-20 Transfer event imzası hash'i (keccak256("Transfer(address,address,uint256)"))
TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378fa423fbc06593bb298642756aed87445579"

def get_contract_events(from_block, to_block, contract_address=None, topics=None):
    """
    Belirli bir blok aralığındaki ve belirli kriterlere uyan olay loglarını çeker.
    """
    params = [{
        "fromBlock": hex(from_block),
        "toBlock": hex(to_block)
    }]
    if contract_address:
        params[0]["address"] = contract_address
    if topics:
        params[0]["topics"] = topics

    response = make_rpc_call("eth_getLogs", params)
    if response and 'result' in response:
        return response['result']
    return None

# Örnek kullanım: USDC (0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48) token'ının transfer olaylarını izle
# USDC_CONTRACT_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
#
# latest_num = get_latest_block_number()
# if latest_num:
#    # Son 10 bloktaki USDC transfer olaylarını çekelim
#    events = get_contract_events(latest_num - 10, latest_num,
#                                 contract_address=USDC_CONTRACT_ADDRESS,
#                                 topics=[TRANSFER_EVENT_TOPIC])
#    if events:
#        print(f"Son 10 blokta {len(events)} adet USDC Transfer olayı bulundu:")
#        for event in events:
#            print(f"  Blok: {int(event['blockNumber'], 16)}, Tx Hash: {event['transactionHash'][:10]}...")
#            # Olay verilerini yorumlamak için ABI ve daha fazla mantık gerekir.
#            # Burada sadece ham log verilerini görüyoruz.
#            print(f"  Topics: {event['topics']}")
#            print(f"  Data: {event['data']}")