निगरानी करना Solana तरलता पूल के साथ Solana gRPC (जाओ)

पढ़ने में 9 मिनट लगेंगे

अवलोकन

Quicknode 's Solana gRPC ( Yellowstone -संगत गीज़र gRPC ) एक शक्तिशाली है gRPC इंटरफ़ेस पर निर्मित Solana 's गीज़र प्लगइन सिस्टम जो streams ब्लॉकचेन डेटा वास्तविक समय में। इस सेवा से जुड़कर, आप एक साथ कई DEX पूलों में गतिविधि को ट्रैक कर सकते हैं, लेनदेन पैटर्न का विश्लेषण कर सकते हैं और ऐसे प्रतिक्रियाशील एप्लिकेशन बना सकते हैं जिन्हें मिलीसेकंड तक के डेटा की आवश्यकता होती है।

इस गाइड में, आप निम्नलिखित बातें जानेंगे:

इसके लिए एक Go वातावरण स्थापित करें Solana gRPC
SOL/USDC पूल लेनदेन की सदस्यता लेने के लिए एक क्लाइंट बनाएं
सक्रिय रेडियम लिक्विडिटी पूल में होने वाले लेन-देन की निगरानी करें
बुनियादी सांख्यिकी के साथ लेनदेन प्रवाह क्षमता का विश्लेषण करें

आवश्यक शर्तें

एक Quicknode खाता जिसमें Solana gRPC एक्सेस (स्केल और बिजनेस प्लान के साथ शामिल है, या बिल्ड एंड एक्सेलरेट पर Solana gRPC ऐड-ऑन के माध्यम से उपलब्ध है)
गो प्रोग्रामिंग की बुनियादी जानकारी
आपके कंप्यूटर पर Go (संस्करण 1.18+) स्थापित होना चाहिए।

समझ Solana gRPC और गीजर

गीजर क्या है?

गीजर है Solana Geyser का प्लगइन सिस्टम वैलिडेटर्स को भारी RPC लोड डाले बिना रियल-टाइम ब्लॉकचेन डेटा को बाहरी सिस्टम्स में स्ट्रीम करने में सक्षम बनाता है। RPC कॉल्स के माध्यम से बार-बार ब्लॉकचेन की जाँच करने के बजाय, Geyser डेटा उपलब्ध होते ही उसे भेज देता है, जिससे लेटेंसी और रिसोर्स का उपयोग काफी कम हो जाता है।

क्या है Solana gRPC ?

Solana gRPC यह एक उच्च-प्रदर्शन, टाइप-सेफ स्ट्रीमिंग इंटरफ़ेस है जो इस पर निर्मित है Solana यह गीज़र प्लगइन है। यह स्ट्रीमिंग प्रदान करता है:

खाता अपडेट
लेनदेन
प्रविष्टियां
सूचनाओं को ब्लॉक करें
स्लॉट सूचनाएं

DeFi एप्लिकेशन और ट्रेडिंग सिस्टम के लिए, यह रीयल-टाइम डेटा एक्सेस एक महत्वपूर्ण प्रतिस्पर्धी बढ़त प्रदान कर सकता है।

अपना वातावरण स्थापित करना

सबसे पहले, आइए एक नया गो प्रोजेक्ट बनाएं और आवश्यक निर्भरताओं को स्थापित करें।

एक प्रोजेक्ट डायरेक्टरी बनाएं:

mkdir solana -dex-monitor && सीडी solana -डेक्स-मॉनिटर

Go मॉड्यूल को प्रारंभ करें:

go mod init solana -डेक्स-मॉनिटर

आवश्यक निर्भरताएँ स्थापित करें:

go get google.golang.org/ grpc

go get github.com/joho/godotenv

go get github.com/mr- tron /बेस58

go get github.com/rpcpool/ yellowstone - grpc /उदाहरण/गोलैंग/प्रोटो

एक बनाने के .पर्यावरण अपनी फ़ाइल को संग्रहीत करने के लिए Quicknode साख:

qn_grpc_url=your-quicknode-endpoint.grpc.solana.quiknode.pro:443
qn_grpc_token=your-quicknode-token

आप अपने कॉन्फ़िगरेशन के बारे में जानकारी प्राप्त कर सकते हैं endpoint हमारे दस्तावेज़ों में, यहाँ।

लिक्विडिटी पूल मॉनिटर का निर्माण

अब, आइए लिक्विडिटी पूल लेनदेन की निगरानी के लिए अपना मुख्य एप्लिकेशन बनाते हैं। इस उदाहरण के लिए, हम Raydium पर एक बहुत सक्रिय SOL/USDC पूल, 3ucNos4NbumPLZNWztqGHNFFgkHeRMBQAVemeeomsUxv का उपयोग करेंगे, लेकिन आप आसानी से अतिरिक्त पूल जोड़ सकते हैं या इसे अन्य पूलों या DEXes के लिए अनुकूलित कर सकते हैं।

एक फ़ाइल बनाएँ जिसका नाम हो main.go और निम्नलिखित कोड जोड़ें:

package main

import (
	"प्रसंग"
	"क्रिप्टो/टीएलएस"
	"एफएमटी"
	"लकड़ी का लट्ठा"
	"os"
	"strings"
	"sync"
	"समय"

	pb "github.com/rpcpool/yellowstone-grpc/examples/golang/proto"

	"github.com/joho/godotenv"
	"github.com/mr-tron/base58"
	"google.golang.org/ grpc "
	"google.golang.org/ grpc /साख"
	"google.golang.org/grpc/encoding/gzip"
	"google.golang.org/grpc/keepalive"
)

var (
	endpoint string
	token    string
)

var SolUsdcPoolAddresses = []string{
	"3ucNos4NbumPLZNWztqGHNFFgkHeRMBQAVemeeomsUxv", // Example Raydium SOL/USDC pool
	// Add more pool addresses as needed
}

// Load environment variables
func init() {
	err := godotenv.Load()
	if err != nil {
		log.Fatalf("Error loading .env file: %v", err)
	}

	endpoint = getEnv("qn_grpc_url", "example.com:10000") // Default value as fallback
	token = getEnv("qn_grpc_token", "token")
}

// Helper function to get environment variable with a default value
func getEnv(key, defaultValue string) string {
	value := os.Getenv(key)
	if value == "" {
		return defaultValue
	}
	return value
}

// PoolTxStats tracks statistics for transactions
type PoolTxStats struct {
	txCount     int
	firstTxTime time.Time
	lastTxTime  time.Time
	mutex       sync.Mutex
}

// Global variables for tracking statistics
var (
	poolStats  = make(map[string]*PoolTxStats) // Key is slot as string
	statsMutex sync.RWMutex
)

type tokenAuth struct {
	token string
}

func (t tokenAuth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{
		"authorization": t.token,
	}, nil
}

func (t tokenAuth) RequireTransportSecurity() bool {
	return true
}

// Function to safely extract signature from transaction
func extractSignature(tx *pb.SubscribeUpdateTransaction) string {
	if tx == nil {
		return "No transaction"
	}

	if sig := tx.GetTransaction().GetSignature(); len(sig) > 0 {
		// Convert the binary signature to base58
		return base58.Encode(sig)
	}

	return "No signature found"
}

func boolPtr(b bool) *bool {
	return &b
}

func main() {
	// Setup connection parameters
	kacp := keepalive.ClientParameters{
		Time:                10 * time.Second,
		Timeout:             5 * time.Second,
		PermitWithoutStream: true,
	}

	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
		grpc.WithKeepaliveParams(kacp),
		grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(1024*1024*1024), grpc.UseCompressor(gzip.Name)),
		grpc.WithPerRPCCredentials(tokenAuth{token: token}),
	}

	// Establish connection
	conn, err := grpc.Dial(endpoint, opts...)
	if err != nil {
		log.Fatalf("Failed to connect: %v", err)
	}
	defer conn.Close()

	client := pb.NewGeyserClient(conn)

	// Create subscription request for SOL/USDC liquidity pool transactions
	transactions := make(map[string]*pb.SubscribeRequestFilterTransactions)
	transactions["sol_usdc_pool_txs"] = &pb.SubscribeRequestFilterTransactions{
		Vote:            boolPtr(false),
		Failed:          boolPtr(false),
		AccountInclude:  SolUsdcPoolAddresses,
		AccountExclude:  []string{},
		AccountRequired: []string{}, 
	}

	commitment := pb.CommitmentLevel_CONFIRMED
	subReq := &pb.SubscribeRequest{
		Transactions: transactions,
		Commitment:   &commitment,
	}

	fmt.Println("Connecting to Solana gRPC...")
	stream, err := client.Subscribe(context.Background())
	if err != nil {
		fmt.Printf("Failed to subscribe to Solana gRPC: %v\n", err)
		return
	}

	fmt.Println("Sending subscription request for SOL/USDC pool transactions...")
	if err = stream.Send(subReq); err != nil {
		fmt.Printf("Failed to send subscription request: %v\n", err)
		return
	}

	// Print header for pool statistics
	fmt.Printf("\n%-12s %-12s %-15s %-20s\n",
		"Slot", "TX Count", "TX/sec", "Total Time (ms)")
	fmt.Println(strings.Repeat("-", 65))

	// Print stats every 5 seconds
	lastPrintTime := time.Now()
	printInterval := time.Second * 5

	fmt.Println("Monitoring SOL/USDC liquidity pool transactions...")
	for {
		m, err := stream.Recv()
		if err != nil {
			fmt.Printf("Failed to receive Solana gRPC message: %v\n", err)
			return
		}

		if tx := m.GetTransaction(); tx != nil {
			// Extract the transaction signature
			signature := extractSignature(tx)

			// Process the transaction using the slot to keep track
			slot := tx.GetSlot()
			now := time.Now()

			// Maintain a simplified tracking approach based on slot
			statsMutex.Lock()
			slotStr := fmt.Sprintf("%d", slot)
			if _, exists := poolStats[slotStr]; !exists {
				poolStats[slotStr] = &PoolTxStats{
					firstTxTime: now,
					lastTxTime:  now,
				}
			}

			stats := poolStats[slotStr]
			stats.mutex.Lock()
			stats.txCount++
			stats.lastTxTime = now
			stats.mutex.Unlock()
			statsMutex.Unlock()

			// Print transaction info with signature
			fmt.Printf("Pool transaction detected at Slot=%d\nSignature=%s\n", slot, signature)

			// Print statistics periodically
			if now.Sub(lastPrintTime) >= printInterval {
				printPoolStats()
				lastPrintTime = now

				// Cleanup old statistics
				cleanupOldStats()
			}
		}
	}
}

func printPoolStats() {
	statsMutex.RLock()
	defer statsMutex.RUnlock()

	fmt.Println("\nTransaction Statistics:")
	fmt.Printf("\n%-12s %-12s %-15s %-20s\n",
		"Slot", "TX Count", "TX/sec", "Total Time (ms)")
	fmt.Println(strings.Repeat("-", 65))

	for slotStr, stats := range poolStats {
		stats.mutex.Lock()
		duration := stats.lastTxTime.Sub(stats.firstTxTime).Milliseconds()
		var txPerSec float64
		if duration > 0 {
			txPerSec = float64(stats.txCount) / (float64(duration) / 1000.0)
		}

		fmt.Printf("%-12s %-12d %-15.2f %-20d\n",
			slotStr,
			stats.txCount,
			txPerSec,
			duration,
		)
		stats.mutex.Unlock()
	}
	fmt.Println()
}

func cleanupOldStats() {
	statsMutex.Lock()
	defer statsMutex.Unlock()

	now := time.Now()
	for slotStr, stats := range poolStats {
		stats.mutex.Lock()
		// Remove statistics older than 1 minute
		if now.Sub(stats.lastTxTime) > time.Minute {
			delete(poolStats, slotStr)
		}
		stats.mutex.Unlock()
	}
}

कोड को समझना

आइए हमारे एप्लिकेशन के प्रमुख घटकों को विस्तार से समझते हैं:

कॉन्फ़िगरेशन और सेटअप

पूल पतेहम उदाहरण के तौर पर SOL/USDC पूल पतों की एक सूची परिभाषित करते हैं—इस उदाहरण के लिए, हम एक सक्रिय Raydium पूल का उपयोग कर रहे हैं। आप सूची में जोड़कर और पूल जोड़ सकते हैं। SolUsdcPoolAddresses टुकड़ा।
प्रमाणीकरण: द टोकन प्रमाणीकरण स्ट्रक्चर आपके साथ प्राधिकरण को संभालता है Quicknode टोकन।
कनेक्शन सेटअप : हम कॉन्फ़िगर करते हैं gRPC TLS, कम्प्रेशन और कीपअलाइव पैरामीटर के साथ कनेक्शन सेटिंग्स।

लेनदेन सदस्यता

हमारी निगरानी प्रणाली का मूल आधार सदस्यता अनुरोध है:

transactions["sol_usdc_pool_txs"] = &pb.SubscribeRequestFilterTransactions{
    Vote:            boolPtr(false),
    Failed:          boolPtr(false),
    AccountInclude:  SolUsdcPoolAddresses,
    AccountExclude:  []string{},
    AccountRequired: []string{}, 
}

यह फ़िल्टर:

मतदान संबंधी लेनदेन इसमें शामिल नहीं हैं।
इसमें केवल सफल लेन-देन शामिल हैं
यह DEX प्रोग्राम ID या विशिष्ट पूल खातों से संबंधित गतिविधियों की निगरानी करता है।

लेनदेन प्रसंस्करण

प्रत्येक आने वाले लेनदेन के लिए:

हम हस्ताक्षर को निकालने के लिए इसका उपयोग करते हैं। हस्ताक्षर निकालें समारोह
प्रत्येक स्लॉट के लिए लेनदेन की संख्या और समय को ट्रैक करें
समय-समय पर आंकड़े (प्रति सेकंड लेनदेन, कुल अवधि) की गणना करें और प्रदर्शित करें।
मेमोरी के उपयोग को प्रबंधित करने के लिए पुराने आंकड़ों को साफ करें

मॉनिटर चलाना

मॉनिटर चलाने के लिए:

go run main.go

आपको कुछ इस तरह का आउटपुट दिखाई देगा:

Connecting to Solana gRPC...
Sending subscription request for SOL/USDC pool transactions...

Slot        TX Count     TX/sec         Total Time (ms)     
-----------------------------------------------------------------
Monitoring SOL/USDC liquidity pool transactions...
Pool transaction detected at Slot=212439883
Signature=4ZV7JsQTwQfLWtN9YMu2EJkTKjyAC9Yjjd1TGY8X5qvqYhfpfTKk3PUK5NZ2P9HFfxXUE2mRJsW2LcUfTF1oTBcP

Transaction Statistics:

Slot        TX Count     TX/sec         Total Time (ms)     
-----------------------------------------------------------------
212439883   1            0.20           5000

मॉनिटर को बेहतर बनाना

क्या आप और भी कुछ बनाना चाहते हैं? अपने मॉनिटर को बेहतर बनाने के लिए यहां कुछ सुझाव दिए गए हैं:

1. और पूल जोड़ें

आप उनके पते शामिल करके निगरानी के लिए आसानी से और अधिक पूल जोड़ सकते हैं। SolUsdcPoolAddresses टुकड़ा:

var SolUsdcPoolAddresses = []string{
	"3ucNos4NbumPLZNWztqGHNFFgkHeRMBQAVemeeomsUxv", // Example Raydium SOL/USDC pool
	// Add more pool addresses as needed
}

2. लेन-देन डेटा का विश्लेषण करें

केवल लेन-देन की गिनती करने के बजाय, आप लेन-देन डेटा को डिकोड करके स्वैप राशि, मूल्य प्रभाव और अन्य विवरण निकाल सकते हैं:

// Add this function to decode transaction data
func decodeTransaction(tx *pb.SubscribeUpdateTransaction) {
    // Parse transaction data based on the program ID
    // Different DEXes (Orca, Raydium, Jupiter) have different transaction structures
}

3. विश्लेषण के लिए डेटा संग्रहित करें

बाद में विश्लेषण के लिए लेनदेन डेटा को संग्रहित करने हेतु मॉनिटर को डेटाबेस से कनेक्ट करें:

// Add database integration
func storeTransactionData(slot uint64, signature string, details map[string]interface{}) {
    // Insert into database (PostgreSQL, InfluxDB, etc.)
}

4. मूल्य अलर्ट लागू करें

खाता डेटा का विश्लेषण करने के बाद, आप कीमतों में महत्वपूर्ण उतार-चढ़ाव या असामान्य गतिविधि का पता लगाने के लिए तर्क जोड़ सकते हैं:

// Add price monitoring
func detectPriceAnomaly(currentPrice, previousPrice float64) bool {
    // Implement anomaly detection logic
    percentChange := (currentPrice - previousPrice) / previousPrice * 100
    return math.Abs(percentChange) > 1.0 // Alert on 1% price change
}

लपेटें

का उपयोग करते हुए Solana gRPC Go के साथ निगरानी करने का एक शक्तिशाली तरीका मिलता है Solana बेहद कम विलंबता वाले लिक्विडिटी पूल। यह दृष्टिकोण एक साथ कई प्रोग्रामों में DEX गतिविधि की रीयल-टाइम ट्रैकिंग को सक्षम बनाता है, जिससे आपको ट्रेडिंग, विश्लेषण या निगरानी अनुप्रयोगों के लिए आवश्यक डेटा मिलता है।

ट्रेडिंग बॉट्स या आर्बिट्रेज सिस्टम के लिए जहां मिलीसेकंड मायने रखते हैं, Solana gRPC स्ट्रीमिंग दृष्टिकोण पारंपरिक आरपीसी विधियों की तुलना में महत्वपूर्ण लाभ प्रदान करता है। सीधे तौर पर इसका उपयोग करके Solana ब्लॉकचेन डेटा फायरहोज की मदद से, आप बाजार में होने वाले उतार-चढ़ाव की जानकारी तुरंत प्राप्त कर सकते हैं।

अतिरिक्त संसाधन

If you have any questions or need help implementing your Solana dApp, join our Discord community or reach out to our support team!

निगरानी करना Solana तरलता पूल के साथ Solana gRPC (जाना)

अवलोकन​

आवश्यक शर्तें​

समझ Solana gRPC और गीजर​

गीजर क्या है?​

क्या है Solana gRPC ?​

अपना वातावरण स्थापित करना​

लिक्विडिटी पूल मॉनिटर का निर्माण​

कोड को समझना​

कॉन्फ़िगरेशन और सेटअप​

लेनदेन सदस्यता​

लेनदेन प्रसंस्करण​

मॉनिटर चलाना​

मॉनिटर को बेहतर बनाना​

1. और पूल जोड़ें​

2. लेन-देन डेटा का विश्लेषण करें​

3. विश्लेषण के लिए डेटा संग्रहित करें​

4. मूल्य अलर्ट लागू करें​

लपेटें​

अतिरिक्त संसाधन​