😱 SOLANA Аналитика

пишем инструмент, анализирующий данные блокчейна

{ транзакции, смарт-контракты, токены + предоставляем пользователю статистику, графики и предупреждения }

pip install solana matplotlib requests нужные либы

> Подключаемся к паблик RPC Solana (с приватным будет больше скорость и безопасность 😎 )

solana_client = Client("https://api.mainnet-beta.solana.com")

> Получение данных о блокчейне

def get_blockchain_info():
    # текущий слот
    slot = solana_client.get_slot()
    print(f"Текущий слот: {slot}")

    # кол-во транзакций в последнем блоке
    block = solana_client.get_block(slot)
    if block and 'result' in block:
        transactions = block['result']['transactions']
        print(f"Количество транзакций в последнем блоке: {len(transactions)}")
    else:
        print("Не удалось получить данные о блоке.")

get_blockchain_info()

> Анализ транзакций

{ извлекаем инфу о количестве переданных $SOL и какие адреса участвовали }

def analyze_transactions(transactions):
total_sol_transferred = 0
participants = set()

for tx in transactions:
    # извлекаем информацию о передаче SOL
    if 'message' in tx and 'instructions' in tx['message']:
        for instruction in tx['message']['instructions']:
            if 'parsed' in instruction and instruction['parsed']['type'] == 'transfer':
                lamports = int(instruction['parsed']['info']['lamports'])
                sol_amount = lamports / 1e9  # Конвертируем lamports -> SOL
                total_sol_transferred += sol_amount
                participants.add(instruction['parsed']['info']['source'])
                participants.add(instruction['parsed']['info']['destination'])

print(f"Общее количество переданных SOL: {total_sol_transferred}")
print(f"Уникальные участники: {len(participants)}")

# вызов функции анализа транзакций

block = solana_client.get_block(solana_client.get_slot())

if block and 'result' in block:
analyze_transactions(block['result']['transactions'])

> Визуализируем данные

def plot_transaction_history(blocks_to_analyze=10):
    slots = []
    transaction_counts = []

    current_slot = solana_client.get_slot()
    for i in range(blocks_to_analyze):
        block = solana_client.get_block(current_slot - i)
        if block and 'result' in block:
            slots.append(current_slot - i)
            transaction_counts.append(len(block['result']['transactions']))

    plt.plot(slots, transaction_counts, marker='o')
    plt.noscript("Количество транзакций в последних блоках")
    plt.xlabel("Слот")
    plt.ylabel("Количество транзакций")
    plt.grid(True)
    plt.show()

plot_transaction_history()

> Добавление предупреждений 🔫

{ если количество транзакций в блоке превышает определенный порог }

def check_for_high_activity(threshold=100):
block = solana_client.get_block(solana_client.get_slot())
if block and 'result' in block:
transaction_count = len(block['result']['transactions'])
if transaction_count > threshold:
print(f"Внимание! Высокая активность: {transaction_count} транзакций в последнем блоке.")
else:
print(f"Активность в норме: {transaction_count} транзакций.")

check_for_high_activity()

🧟‍♂️ Что происходит то?

> Получать данные о последнем блоке

> Анализируем транзакции

> Визуализируем историю транзакций

> Предупреждаем о высокой активности

удобная визуализация Solana, далее можно сохранять все в базу, анализировать определенные токены и т.д ))

Ваши идеи на следующий МОЩНЫЙ разбор? 🤬

😨 SPL ТОКЕНЫ & ВЗАИМОДЕЙСТВИЕ

pip install solana spl-token либы

😔 разберем техническую часть

Настройка клиента и ключей

# подключение к сети Solana (devnet)

client = Client("https://api.devnet.solana.com")

# приватный ключ (отправитель)

sender_keypair = Keypair.from_secret_key(bytes([...])) 

# публичный ключ отправителя

sender_pubkey = sender_keypair.public_key

# публичный ключ получателя

receiver_pubkey = PublicKey("...")

# адрес SPL-токена (USDC -> devnet)

token_mint_pubkey = PublicKey("...")

# адрес ассоциированного аккаунта отправителя

sender_token_account = PublicKey("...")

receiver_token_account = PublicKey("...")

😏 Создаем Транзу передачи SPL ТОКЕНОВ

amount = 1000000  # 1 USDC, если у токена 6 знаков после запятой

# создание инструкции для передачи токенов
transfer_instruction = transfer_checked(
    TransferCheckedParams(
        program_id=TOKEN_PROGRAM_ID,
        source=sender_token_account,
        mint=token_mint_pubkey,
        dest=receiver_token_account,
        owner=sender_pubkey,
        amount=amount,
        decimals=6,  # Количество знаков после запятой у токена
        signers=[],
    )
)

# Создание транзакции
transaction = Transaction().add(transfer_instruction)


Подпись + отправка

# подписание транзакции

transaction.sign(sender_keypair)

# отправка транзакции

txid = client.sendTransaction(transaction, sender_keypair, opts=TxOpts(skip_preflight=True))

# ожидание подтверждения транзакции

client.confirm_transaction(txid['result'])

print(f"Транзакция отправлена: {txid['result']}")

проверяем баланс пользователя (getTokenAccountBalance)

balance = client.getTokenAccountBalance(receiver_token_account)
print(f"Баланс получателя: {balance['result']['value']['amount']}")

🤩 P.S для работы с mainnet заменяем https://api.devnet.solana.com на https://api.mainnet-beta.solana.com.


Кидайте свои идеи на МОЩНЫЙ разбор 🤲

😘 SOLANA с НУЛЯ

это мог быть мощный прогрев на курс, но не сегодня 😔

Разработчики Solana предоставили полный курс по старту разработки в их экосистеме { бесплатно }

> Курс

+ Буткемп на 18 часов материалов на YouTube

> Плейлист

теперь ноу экскьюзес, возможность разобраться есть у каждого 👍

😱 SOLANA & WEBSOCKET | Мониторим все события в экосистеме

Либы

solana-py — для взаимодействия с Solana

websockets — для работы с WebSocket.

pip install solana websockets

🤟 Подключение к Solana через WebSocket

Solana предоставляет WebSocket API для подписки на события в блокчейне

import asyncio
import websockets

async def connect_to_solana():
uri = "wss://api.mainnet-beta.solana.com"  # WebSocket endpoint Solana
async with websockets.connect(uri) as websocket:

Подписка на события
subnoscription_request = {
"jsonrpc": "2.0",
"id": 1,
"method": "logsSubscribe",
"params": [
{"mentions": ["all"]},  # Подписываемся на все события
{"commitment": "confirmed"}
]
}
await websocket.send(json.dumps(subnoscription_request))
print("Подписались на события Solana")

    # Получение данных в реальном времени
    async for message in websocket:
        print("Получено событие:", message)



asyncio.get_event_loop().run_until_complete(connect_to_solana())

Обработка событий 😱

В зависимости от типа события (транзакция, смарт-контракт, изменение аккаунта), выполняем следующие действия.

import json

async def handle_event(event):
event_data = json.loads(event)

Пример обработки события
if "params" in event_data:
log_data = event_data["params"]["result"]["value"]
print("Лог:", log_data)

🤔 Здесь можно добавить логику для обработки конкретных событий

Фильтруем События (конкретный смарт-контракт || аккаунтов)

async def handle_event(event):
event_data = json.loads(event)
if "params" in event_data:
log_data = event_data["params"]["result"]["value"]
if "specific_account_id" in log_data:  # Пример фильтрации по аккаунту
print("Событие для конкретного аккаунта:", log_data)

++ Для масштабирования применим использование очередей (RabbitMQ или Kafka) для обработки событий в параллельном режиме

🎹 НОВАЯ МОЩНАЯ РУБРИКА

1-2 раза в неделю будем разбирать работу популярного софта под L1 L2 проекты 2021 - 2025

+ Для большего понимания буду дропать видосы на эту тему

Затея мощнейшая! Что добавите, кроме ваших реакций? 😔

😑 NFT КОЛЛЕКЦИЯ на SOLANA С НУЛЯ!

кратко и пошагово разбираем процесс

Что требуется?

Node.js (для Metaplex CLI)

Python 3.7+ ⬇️

Solana CLI (для управления кошельком и сетями)

Либы -> pip install solders anchorpy base58

Создание NFT через Metaplex

a. Подготовка метаданных
файл metadata.json:

{
"name": "My NFT",
"symbol": "NFT",
"denoscription": "Описание",
"image": "https://ссылка_на_имаге/image.png",
"attributes": []
}

b. Загрузка метаданных и минтинг NFT (Используем Metaplex CLI)

metaplex upload metadata.json -k ~/.config/solana/devnet.json

После загрузки получаем URI метаданных -> https://arweave.net/xyz

😱 Создание NFT

import json
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solana.rpc.api import Client
from spl.token.instructions import Token
from solana.rpc.types import TxOpts
from spl.token.constants import TOKEN_PROGRAM_ID

# подключаемся к Devnet
client = Client("https://api.devnet.solana.com")

# загрузка приватного ключа из файла
with open("/path/to/devnet.json", "r") as f:
    secret_key = json.load(f)

# создание объекта Keypair из приватного ключа
payer = Keypair.from_bytes(bytes(secret_key[:32]))

# создание NFT (Mint Account)
token = Token.create_mint(
    conn=client,
    payer=payer,
    mint_authority=payer.pubkey(),
    decimals=0,  # NFT имеет 0 десятичных знаков
    program_id=TOKEN_PROGRAM_ID
)

# создаем ассоциированный аккаунт для хранения NFT
associated_account = token.create_associated_token_account(payer.pubkey())

# минтинг 1й NFT
token.mint_to(
    dest=associated_account,
    mint_authority=payer,
    amount=1,
    opts=TxOpts(skip_confirmation=False)
)

print(f"NFT создан! Mint Address: {token.pubkey}")

Добавление метаданных Metaplex (для привязки метаданных к NFT)

Пример через CLI:

metaplex create_nft \\
  -k ~/.config/solana/devnet.json \\
  --uri "https://arweave.net/xyz" \\
  --name "My NFT"

после создания

🔊Находим NFT в Explorer: explorer.solana.com/?cluster=devnet

Проверяем Solana кошелек

вот такая базовая инструкция по созданию нфт, как вам идея написать нашу?? 🎧

Твои первые $100.000 на Solana Разработке

а сейчас разберем бекграунд наших постов по солане начиная с 11 февраля

Код был написал преимущественно на Python + solana-py

😰 Но вот неожиданность, solana-py уже не так хорош и ему в альтернативу пришла solders библитека

😭 Преимущества Solders:

Быстрее т.к используем Rust через PyO3

Лучше совместим с anchorpy (для написания смарт-контрактов на солана)


😜 Что делать с solana-py?

она по прежнему актуальна, будем использовать ее в следующих операциях ⬇️

> solana-py предоставляет удобные методы для работы с RPC-сервером (get_account_info, get_balance). В solders это можно делать, но API сложнее.

> solana-py предоставляет удобный Transaction API, похожий на solana-web3.js, что может быть полезно при миграции web3.js -> solana.py

> В solana-py есть удобные методы для работы с SPL-токенами (spl.token). В solders это тоже возможно, но немного сложнее.

Используем библиотеки вместе, пример

from solders.pubkey import Pubkey
from solders.rpc.responses import GetAccountInfoResp
from solana.rpc.api import Client

# используем solana-py для работы с RPC

client = Client("https://api.devnet.solana")
account_pubkey = Pubkey.from_string("YourPublicKeyHere")

# получаем информацию об аккаунте (solana-py)

account_info = client.get_account_info(account_pubkey)

# преобразуем ответ в формат solders

solders_response = GetAccountInfoResp.from_json(account_info)

print(solders_response)

ПОЧЕМУ Я НЕ ПИШУ НА SOLDERS?

Думаю это мощный прогрев к моей статье по солане где все встанет на свои места!

🔫 Смарт-Контракты Solana - ДЕКОНСТРУКЦИЯ

Смарт-контракты в Solana отличаются от контрактов в Ethereum и других EVM-совместимых блокчейнах.

> Они называются программами и работают в безсостоячном режиме.

> Данные хранятся отдельно в аккаунтах, а не внутри самого смарт-контракта.

🐑 Состав Смарт-Конктракта Solana:

Смарт-Контракты - скомпилированный код, развернутый в блокчейне.

😱 Они выполняются виртуальной машиной BPF (Berkeley Packet Filter).

В Solana все данные хранятся в аккаунтах, а не внутри программы

🔧 Есть два типа аккаунтов:

> Executable Accounts - аккаунты, содержащие скомпилированную программу.

> Data Accounts - аккаунты для хранения состояния.

Инструкции - команды, отправляемые в смарт-контракт ⬇️

Аналогичны вызовам функций в Ethereum.

Транзакции - группы инструкций, выполняемые в одной атомарной операции.

😐 Напишем такой Смарт-Контракт:

Используем seahorse - DSL, который компилируется в Rust для Solana.

pip install seahorse-lang

Пишем смарт-контракт, который хранит число:

from seahorse.prelude import *

declare_id("5hWzF9Pb...")  # адрес программы в Solana

class Counter(Account):
value: i64  # хранит число

@instruction
def initialize(owner: Signer, counter: Empty[Counter]):
counter.init(payer=owner, seeds=["counter"])
counter.value = 0

@instruction
def increment(owner: Signer, counter: Counter):
counter.value += 1

declare_id - объявляет ID программы.

Counter - аккаунт, хранящий число.

initialize - функция инициализации.

increment - функция увеличения числа.

Seahorse скомпилирует его в Rust и позволит деплоить в Solana.

seahorse build - компиляция в Rust

Развернуть через Solana CLI

solana program deploy target/deploy/my_program.so

Ваши ИДЕИ на следующий МОЩНЫЙ разбор?

😰 BYBIT - Разбираемся

похитили около 401 346 ETH ≈ $1,46 млрд

Что произошло?

использовась технику подмены интерфейса пользователя (UI spoofing), что позволило получить доступ к одному из холодных кошельков Ethereum биржи.

😎 Хакеры манипулировали процессом подписания транзакций, подменяя данные таким образом, что участники видели корректный адрес получателя, но фактически подтверждали измененную транзакцию.

Как это реализовывается?

Добавляется JavaScript-код на сайте или в расширении кошелька, который: ⬇️

> Перехватывает и изменяет отображаемые пользователю данные

> Меняет содержимое транзакции перед подписью

🎹 Подмена адреса получателя

Когда пользователь инициирует перевод, злоумышленник изменяет отображаемый адрес на подлинный (биржи), но перед подписанием транзакции он меняется на адрес хакера.

🤔 Пример реализации через JavaScript

// Вредоносный код в расширении браузера или на фишинговом сайте
document.getElementById("recipient-address").value = "0xCorrectAddress";  // Подлинный адрес
document.getElementById("amount").value = "10"; 

// Перехват перед подписанием
window.ethereum.request = async (args) => {
if (args.method === "eth_sendTransaction") {
let tx = args.params[0];
console.log("Оригинальная транзакция:", tx);

    // Подмена адреса получателя на адрес хакера
    tx.to = "0xHackerAddress";

    console.log("Измененная транзакция:", tx);
    return originalEthereumRequest({ method: "eth_sendTransaction", params: [tx] });
}

return originalEthereumRequest(args);

};

Код отображает жертве "правильный" адрес, но перед подписанием транзакции изменяет его на адрес хакера.

Подмена Суммы Перевода:

tx.value = "0xde0b6b3a7640000"; // 1 ETH вместо 0.1 ETH

В нашем случае хакеры могли внедрить код в интерфейс биржи или кошелька, который перехватывал и изменял отображаемые пользователю данные. Это могло быть достигнуто через компрометацию веб-сайта биржи, использование фишинговых сайтов или вредоносных расширений браузера.

Что делать? 🔫

> нам, как юзерам не держать все на биржах, использовать базовую диверсификацию

ну и ☔️

> Включаем Google Authenticator 2FA и отключить SMS.

> Настроить белый список адресов для вывода.

> Проверить URL перед входом в аккаунт.

> Регулярно проверяйте активность аккаунта (IP)

ваши МЫСЛИ?

☺️ ПАМП-ФАН | Пишем СОФТ

Функционал

1⃣ Отслеживание недавно созданных токенов на Pump.fun

2⃣ Фильтрация по количеству минтеров, ликвидности, цене

3⃣ Выдача сигналов о перспективных мемах.

для получения данных будем использовать сторонний апи - pumpportal.fun

pip install requests

Параметры

import requests
import time

# URL для получения данных о новых токенах

API_URL = "https://pumpportal.fun/api/new-tokens"

# пороговые значения для фильтрации

MIN_MINTERS = 100       # Минимальное количество минтеров
MIN_LIQUIDITY = 10      # Минимальная ликвидность в SOL
MIN_PRICE = 0.001       # Минимальная цена в SOL
MAX_PRICE = 1           # Максимальная цена в SOL

# интервал проверки (в секундах)

CHECK_INTERVAL = 60

Получение данных о новых токенах

def fetch_new_tokens():
try:
response = requests.get(API_URL)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"Ошибка при получении данных: {e}")
return []

Фильтрации токенов по заданным критериям

def filter_tokens(tokens):
filtered = []
for token in tokens:
minters = token.get('minters', 0)
liquidity = token.get('liquidity', 0)
price = token.get('price', 0)

    if (minters >= MIN_MINTERS and
        liquidity >= MIN_LIQUIDITY and
        MIN_PRICE <= price <= MAX_PRICE):
        filtered.append(token)
return filtered

Основной Цикл МОНИТОРИНГА

def main():
print("Запуск мониторинга новых мемкоинов на Pump.fun...")
while True:
tokens = fetch_new_tokens()
if tokens:
filtered_tokens = filter_tokens(tokens)
for token in filtered_tokens:
notify(token)
else:
print("Нет новых токенов или ошибка при получении данных.")

    time.sleep(CHECK_INTERVAL)

if name == "main":
main()

Кратко расписал как это будет выглядеть

😠 Далее можно добавлять:

> более точные критерии отбора токенов

> отслеживать ранних минтеров

> настроить лимиты на покупку

> И самое интересное проверять механизмы блокировки продаж в смарт-контракте + исключать токены с высоким налогом на продажу (sell tax).

ВАШИ МЫСЛИ?

🙏 Закрытый Club, Buddy

создал канал, где мы будем развивать web3 сообщество, билдить, изучать и становиться лушче

forms.gle/bbf2Cecu9Bovq2gj9

Первый Набор - 10 человек, далее будем расширяться

💵 Вход: $БЕСПЛАТНО

Всем Удачи 🪑

🤵‍♂️ ВЫСОКОПРОИЗВОДИТЕЛЬНЫЕ транзакции Solana + Python

как Solana обрабатывает транзы: ⬇️

Параллелизм:

Solana использует модель Sealevel, что позволяет выполнять независимые транзакции параллельно.

Счета (Accounts) 💰

Транзакции блокируются, если пытаются одновременно модифицировать один и тот же счет.

Приоритизация (Prioritization Fees)

Solana позволяет пользователям платить дополнительные комиссии, чтобы увеличить шансы включения транзакции в блок.

👍 Для максимальной производительности “избегаем” конкуренции за доступ к счетам и используем prioritization fees.

Сегодня для большей эффективности используем solders

solders работает в 5-10 раз быстрее при обработке транзакций, чем solana-py, за счет прямых биндингов к Rust.

😐 solders позволяет быстро формировать транзакции без лишних зависимостей.

Асинхронные запросы в solders позволяют отправлять сотни транзакций в секунду 😐


pip install solders

подключаем либы

from solders.rpc.api import Client
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.transaction import Transaction
from solders.instruction import Instruction
from solders.message import Message
from solders.system_program import transfer
from solders.commitment_config import CommitmentLevel

🍷 Подключение к RPC и генерация ключей

# подключаемся к Solana RPC

RPC_URL = "https://api.mainnet-beta.solana.com"
client = Client(RPC_URL)

# генерим ключи (или загружаем существующие)

sender_keypair = Keypair()
receiver_pubkey = Pubkey.from_string("адрес_получателя")

print(f"Отправитель: {sender_keypair.pubkey()}")
print(f"Получатель: {receiver_pubkey}")

Создание и подпись транзакции

# получаем актуальный блокхеш

latest_blockhash = client.get_latest_blockhash(commitment=CommitmentLevel.Finalized).value

# создаем инструкцию перевода 0.001 SOL ((

instruction = transfer(sender_keypair.pubkey(), receiver_pubkey, 1000000)

# формируем транзу

message = Message([instruction], sender_keypair.pubkey())
transaction = Transaction(message, [sender_keypair], latest_blockhash)

🔧 Отправка транзакции с приоритетными комиссиями

prioritization_fee = 5000  # устанавливаем дополнительную комиссию

# добавляем fee payer и приоритетные комиссии

transaction = transaction.set_fee_payer(sender_keypair.pubkey())
transaction = transaction.set_prioritization_fee(prioritization_fee)

# подписываем транзу

transaction = transaction.sign([sender_keypair])

# отправляем транзу

response = client.send_transaction(transaction)

print("Транзакция отправлена:", response)

Приоритетные комиссии позволяют увеличить вероятность включения транзакции в блок.

Параллельная отправка транзакций (asyncio)

import asyncio
from solders.rpc.api import AsyncClient

async def send_transaction_async(tx, client):
async with AsyncClient(RPC_URL) as async_client:
return await async_client.send_transaction(tx)

async def main():
tasks = [send_transaction_async(transaction, client) for _ in range(10)]  # Отправляем 10 транзакций параллельно
results = await asyncio.gather(*tasks)
print(results)

asyncio.run(main())

🧃 Используем Durable Nonces

во избежания устаревания blockhash, используем durable nonce:

# генерим nonce-аккаунт

nonce_account = Keypair()
txn = Transaction(
Message([transfer(sender_keypair.pubkey(), nonce_account.pubkey(), 1000000)]),
[sender_keypair],
latest_blockhash
)

client.send_transaction(txn)  # отправляем транзакцию для создания nonce-аккаунта

# используем nonce в будущих транзакциях

nonce_value = client.get_account_info(nonce_account.pubkey()).value
txn = txn.set_recent_blockhash(nonce_value)

😴 Durable Nonces позволяют избежать ошибок при высокой нагрузке.

В результате, мы получаем максимальную производительность наших Solana транзакций!! 😜

ЧТО РАЗБИРАЕМ ДАЛЕЕ?? ИДЕИ, МЫСЛИ 🔥 💀

😱 SOLANA | Ускоряем запросы + минимизируем затраты

Высокая нагрузка на RPC приводит к 🐺

> Медленной обработке транзакций.

> Большому числу ограничений на запросы.

> Увеличению затрат при использовании платных RPC.


🤷‍♂️ Как работают RPC-запросы в Solana

Solana использует JSON-RPC API для работы с блокчейном

Основные запросы:

getAccountInfo – получение данных о кошельке или смарт-контракте.

getProgramAccounts – поиск всех аккаунтов, связанных с программой.

getTransaction – получение информации о транзакции.

simulateTransaction – эмуляция транзакции перед отправкой.

эти запросы могут нагружать RPC, если их делать неправильно

🥳 УСКОРЯЕМ RPC

Используем solders вместо solana-py

она быстрее, т.к использует Rust-биндинги вместо чистого Python + больше безопасности и сериализация транзакций

2. WebSockets вместо REST

REST-запросы к RPC - лишние расходы.

Вместо этого можно подписываться на события через WebSockets, чтобы получать обновления мгновенно, без лишних запросов))

например подписка на обновления баланса кошелька через WebSockets

import asyncio
from solders.rpc.websocket import SolanaWsClient

async def listen_to_account_changes():
async with SolanaWsClient("wss://api.mainnet-beta.solana.com") as ws:
subnoscription_id = await ws.account_subscribe("PublicKey")

    async for msg in ws:
        print("Account update:", msg)



asyncio.run(listen_to_account_changes())

3.Кеширование (Redis)

Частые запросы к getAccountInfo или getTransaction можно кешировать.

кеширования баланса через Redis

import redis
import json
from solders.rpc.api import Client
from solders.pubkey import Pubkey

client = Client("https://api.mainnet-beta.solana.com")
redis_client = redis.Redis(host='localhost', port=6379, db=0)

def get_cached_balance(wallet):
cache_key = f"solana_balance:{wallet}"
cached_data = redis_client.get(cache_key)

if cached_data:
    return json.loads(cached_data)

balance = client.get_balance(Pubkey.from_string(wallet)).value
redis_client.setex(cache_key, 60, json.dumps(balance))  # Кешируем на 60 сек
return balance

wallet = "PublicKey"
print(get_cached_balance(wallet))

4.Самый ГЕНИАЛЬНЫЙ СПОСОБ - Полигамия RPC

используем несколько узлов и переключаться между ними.

выбор случайного RPC

import random
from solders.rpc.api import Client

RPC_NODES = [
"https://api.mainnet-beta.solana.com",
"https://solana-mainnet.rpcfast.com",
"https://your-private-rpc.com"
]

def get_rpc_client():
rpc_url = random.choice(RPC_NODES)
return Client(rpc_url)

client = get_rpc_client()
print(client.get_slot().value)

Меньше rate limits

Резервный RPC на случай отказа узла.

вот такой СТАРТОВЫЙ СПИСОК!! КАК ВЫ Работаете с ОПТИМИЗАЦИЕЙ??

Закрытый Канал упдейт

Сегодня последний день принятия заявок

http://forms.gle/bbf2Cecu9Bovq2gj9

Завтра начинаем 🍑

😐 Monad РАЗБЕРЕМ Софт

что за monad?

monad.xyz

L1 совместимый с EVM, разработан для решения проблем масштабируемости и эффективности

параллельное выполнение транзакций и оптимизированная база данных MonadDB, сеть способна обрабатывать до 10 000 транзакций в секунду при времени блока в 0,5 секунды и почти нулевых комиссиях за газ.

🥳 сейчас проект запустил тестнет, но мы что нормисы, чтобы без софта это делать??

СЕГОДНЯ РАЗБЕРЕМ ЧТО ДА КАК!!!

1. Запрос Токенов на testnet.monad.xyz

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time

WALLET_ADDRESS = "0xКошелек”

# настройка WebDriver

options = webdriver.ChromeOptions()
options.add_argument("--headless")  # Запуск без графического интерфейса

driver = webdriver.Chrome(options=options)

def request_tokens():
try:

Открываем страницу крана
driver.get("https://testnet.monad.xyz/")
time.sleep(3)  # Ждем загрузки

    # находим поле ввода и вводим адрес кошелька
    input_field = driver.find_element(By.XPATH, "//input[@type='text']")
    input_field.send_keys(WALLET_ADDRESS)
    time.sleep(1)

    # Нажимаем кнопку запроса токенов
    request_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Request Testnet ETH')]")
    request_button.click()

    print("✅ Запрос тестовых токенов отправлен!")
except Exception as e:
    print("❌ Ошибка при запросе токенов:", e)
finally:
    driver.quit()

# запускаем
request_tokens()

Далее

Переходим на сайт и коннектим кошелёк

Вводим код: 7AA0B | 2B2EB | C51B2 | C24B6 | C26D0

Минтим Rookie NFT

CODES = [
"7AA0B", "2B2EB", "C51B2", "C24B6", "C26D0"
]

options = webdriver.ChromeOptions()
options.add_argument("--headless") 

driver = webdriver.Chrome(options=options)

def mint_nft():
try:

driver.get("https://monad.talentum.id/projects")
time.sleep(3)  # ждем загрузки

    for code in CODES:
        try:
            print(f" Пробуем код: {code}")

            # находим поле ввода кода и вводим его
            input_field = driver.find_element(By.XPATH, "//input[@type='text']")
            input_field.clear()
            input_field.send_keys(code)
            time.sleep(1)

            # нажимаем кнопку подтверждения
            submit_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Submit')]" )
            submit_button.click()
            time.sleep(5)  # ждем ответа

            # проверяем, появилась ли кнопка "Mint Rookie NFT"
            try:
                mint_button = driver.find_element(By.XPATH, "//button[contains(text(), 'Mint Rookie NFT')]")
                mint_button.click()
                print("✅ NFT успешно заминчен!")
                break  # Прекращаем цикл, если удалось заминтить
            except:
                print(f"❌ Код {code} не сработал, пробуем следующий...")
        except Exception as e:
            print(f"⚠ Ошибка с кодом {code}: {e}")
finally:
    driver.quit()
    print("🚀 Скрипт завершил работу.")

#Запуск

mint_nft()

Задачи из гайда я брал тут 🤛

Думаю ПОРА написать ПОЛНОЦЕННЫЙ СОФТ!!

КАК ВАМ ИДЕЯ, ГАЙС????

✏️ ПИШЕМ СОФТ С НУЛЯ

как же стартануть в написании скриптов, РАЗБИРАЕМСЯ

☺️ ОСНОВЫ ПРОГРАММИРОВАНИЯ

Python & JavaScript - шикарные решения для старта в крипто-разработки

Питон хорош для написания ботов, автоматизации и работы с API бирж 🤵‍♂️ ⬇️

✏️ JavaScript (TypeScript) – нужен для взаимодействия со смарт-контрактами и написания фронтенда для DApps.

javanoscript.info

learnpython.org

Прекрасные ресурсы для изучения языков, но без практики никуда

w3resource.com/python-exercises - Задачи на Пайтон

jschallenger.com - Задачи на JS

Задачи 👍

Python: основы синтаксиса, ООП, работа с модулями, обработка ошибок.

JavaScript/TypeScript: основы JS, промисы, async/await, работа с API.

☕️ Подключение к Блокчейну

web3.py - Python

ethers.js - JS

Благодаря этим библиотекам мы смотрем подключиться к блокчейну Ethereum и другим EVM и взаимодействовать с ними

🤩 ДЛЯ полного взаимодействия у нас должна быть НОДА!

Поэтому получаем ключ к ней на

infura.io ИЛИ alchemy.com

😱 НАПИСАНИЕ Скриптов

Начинаем Применять наши знания на практике, мои гайды тому пример

Ethers.js с нуля

web3.py с нуля

КАК ВАМ ТАКОЙ СПИСОК?? Разработчики, добавьте что-то от себя!

🤫 “Скрытые” механики блокчейна

разбираем базу каждого блокчейн-разработчика

😂 Mempool – зона ожидания транзакций

Прежде чем транзакция попадет в блок, она отправляется в mempool – это своего рода «очередь» неподтвержденных транзакций.

Как это?

> Узлы сети принимают транзакции и хранят их в mempool.

> Майнеры/валидаторы выбирают транзакции из mempool для включения в следующий блок.

> Транзакции с высокими комиссиями (gas fee) имеют приоритет.

Как Пайтон анализирует МемПул ?

разберем код для отслеживания транзакций

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/INFURA_KEY"))

def watch_mempool():
while True:
pending_transactions = w3.eth.get_block('pending', full_transactions=True)
for tx in pending_transactions.transactions:
print(f"Транзакция {tx.hash.hex()} с gas price {tx.gasPrice}")

watch_mempool()

😭 Зачем ?

> Выявлять крупные транзакции перед их подтверждением.

> Анализировать, какие комиссии актуальны для быстрой отправки.

> Предугадывать атаки типа frontrunning.

👊 Frontrunning боты

перехватывают твои сделки

Frontrunning - когда кто-то (например, MEV-боты) замечает выгодную сделку в mempool и вставляет свою транзакцию перед ней.

Как?

1⃣ Ты отправляешь транзакцию на покупку токена с высокой ликвидностью.

2⃣ Бот видит твою транзакцию в mempool и отправляет свою раньше с чуть более высоким gas fee.

3⃣ Бот скупает токены раньше тебя и перепродает их по более высокой цене.


Пайтон поможет??

пробуем анализировать транзакции, которые быстро следуют друг за другом с похожими параметрами.

скрипт на поиск подозрительных транзакций

def detect_frontrunning():
pending_transactions = w3.eth.get_block('pending', full_transactions=True)

tx_map = {}
for tx in pending_transactions.transactions:
    sender = tx['from']
    to = tx['to']
    amount = tx['value']

    if (to, amount) in tx_map:
        print(f"⚠️ Возможный фронтраннинг! Отправитель {sender} повторяет транзакцию.")
    tx_map[(to, amount)] = sender

detect_frontrunning()

😐 Что делать с этими данными?

1⃣ Фильтровать мемпул на предмет подозрительных ботов.

2⃣ Настраивать защиту в своих смарт-контрактах.

3⃣ Опережать ботов, если ты делаешь арбитраж.

🏋️ MEV - невидимый рынок внутри блокчейна

MEV (Maximal Extractable Value) – дополнительная прибыль, которую майнеры/валидаторы и боты могут извлечь за счет изменения порядка транзакций в блоке.

Кто использует MEV? 🤬

> Frontrunning-боты

> Sandwich-атаки

> Арбитражные боты, которые используют разницу цен на DEX.

ПАЙТОН - используем для анализила блоков и поиска подозрительных групп транзакций.

def check_mev_transactions(block_number):
block = w3.eth.get_block(block_number, full_transactions=True)
txs = block.transactions

for i in range(len(txs) - 1):
    if txs[i]['to'] == txs[i + 1]['to'] and txs[i]['value'] < txs[i + 1]['value']:
        print(f"⚠️ MEV подозрение: {txs[i].hash.hex()} -> {txs[i + 1].hash.hex()}")


check_mev_transactions("latest")

Зачем ?

1⃣ Можно искать закономерности в транзакциях.

2⃣ Можно разрабатывать стратегии защиты от MEV-атак.

ЧТО РАЗБЕРЕМ ДАЛЕЕ? 💰

😮 Февраль 2025 | Итоги

подведем итоги месяца

1. Разобрались с AI-AGENTS (ЧАСТЬ №1, Часть №2)

2. Начали Работу Над Арбитраж-Ботом на Пайтон

3. Разобрали Multicall & EIP-1559

4. Научились Работать с Капчей через Пайтон

5. Разобрали работу MEV-ботов

6. Работали с Etherscan api & ChainLink

Начали МАРАФОН по Солана на пайтон + Нашли Обучение

Работали с транзакциями соланы и ее скоростью

Солана x DEX

Solana x Кошельки

Солана Legacy VS V0

spl токены солана

БЕСПЛАТНЫЙ курс по солане с НУЛЯ

Разбор Solders

Софтанули Памп-Фан

Бустанули Транзакции в Солане

Ускорили RPC Solana

Начали разработку Софта под Monad

Разобрали Структуру Крипто-Софта в пайтон

Гайд по написанию Софтов с НУЛЯ

Разобрали механики Блокчейна

Запустили Наш ЗАКРЫТЫЙ Клуб

👊 Крипто-Мир

Взлом Байбит на $1.5 млрд