🐸🐸🐸кошельки Solana | управление

создаем keyPair (пару из публичного и приватного ключей)

+ создаем приватный ключ из мнемонической фразы

pip install solana bip32utils mnemonic (либы для соланы и мнем-фразы)

1. Создаем KeyPair

from solana.keypair import Keypair

# создаем новый KeyPair

keypair = Keypair()

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

print("Public Key:", keypair.public_key)
print("Private Key:", keypair.secret_key)

2. Генерация Мнемонической Фразы (seed фраза)

используется для восстановления кошелька

from mnemonic import Mnemonic

# генерация мнемонической фразы

mnemo = Mnemonic("english")
mnemonic_phrase = mnemo.generate(strength=128)  # 12 слов

print("Mnemonic Phrase:", mnemonic_phrase)

3. Деривация приватного ключа из мнемонической фразы

используя мнемоническую фразу, мы можем получить приватный ключ

используем стандарт BIP-39 (генерация seed из мнемонической фразы) и BIP-44 (деривация ключей).

import hashlib
import hmac
from bip32utils import BIP32Key

# преобразуем мнемоническую фразу в seed

seed = mnemo.to_seed(mnemonic_phrase)

# деривация приватного ключа по пути BIP-44

# путь для Solana: m/44'/501'/0'/0'

bip32_key = BIP32Key.fromEntropy(seed)
derived_key = bip32_key.ChildKey(44 + BIP32Key.HARDEN).ChildKey(501 + BIP32Key.HARDEN).ChildKey(0 + BIP32Key.HARDEN).ChildKey(0).ChildKey(0)

# приватный ключ (32 байта)

private_key = derived_key.PrivateKey()
print("Derived Private Key:", private_key.hex())

4. Создаем KeyPair из приватного ключа

когда у нас есть приватный ключ, мы можем создать KeyPair!

from solana.keypair import Keypair

# Преобразуем приватный ключ в KeyPair

keypair = Keypair.from_secret_key(private_key)

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

print("Public Key from Derived Private Key:", keypair.public_key)
print("Private Key from Derived Private Key:", keypair.secret_key.hex())

в результате:

😭 Генерируется 12 слов, которые можно использовать для восстановления кошелька.

Мнемоническая фраза преобразуется в seed с помощью алгоритма PBKDF2.

вот так это и работает

😴 V0 / LEGACY транзакции Solana

Solana поддерживает два типа транзакций:

Legacy (старый формат) & Versioned Transactions (новый формат, поддерживающий дополнительные функции - Account Lookup Tables

Legacy поддерживает перевод SOL или SPL-токенов. + Использует старый формат сообщений (Message) (база)

Пример Legacy Транзакции

# отправка 0.1 SOL

transaction = Transaction().add(
    transfer(
        TransferParams(
            from_pubkey=sender_wallet.public_key,
            to_pubkey=recipient,
            lamports=int(0.1 * 1e9),  # 0.1 SOL в lamports
    )
)

Versioned Transactions (VO) - новый формат транзакций, поддерживающий дополнительные функции: Account Lookup Tables (таблицы поиска аккаунтов).

😠 Они позволяют уменьшить размер транзакций и увеличить пропускную способность сети.

Account Lookup Tables - таблицы, которые позволяют хранить ссылки на аккаунты, уменьшая размер транзакций (полезно для сложных операций - взаимодействие с DEX)

😄 Напишем транзу для Отправка SOL через V0

для V0 нам нужно использовать MessageV0 и VersionedTransaction

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

# кошелек отправителя
sender_wallet = Keypair.from_secret_key([YOUR_PRIVATE_KEY])  # Замените на ваш приватный ключ

# адрес получателя
recipient = PublicKey("RECIPIENT_PUBLIC_KEY_HERE")

# создаем инструкцию для перевода SOL
instruction = transfer(
    TransferParams(
        from_pubkey=sender_wallet.public_key,
        to_pubkey=recipient,
        lamports=int(0.1 * 1e9),  # 0.1 SOL в lamports
    )
)

# создаем MessageV0
message = MessageV0.try_compile(
    payer=sender_wallet.public_key,
    instructions=[instruction],
    address_lookup_table_accounts=[],  # Можно добавить таблицы поиска аккаунтов
    recent_blockhash=client.get_recent_blockhash()["result"]["value"]["blockhash"],
)

# создаем VersionedTransaction
transaction = VersionedTransaction(message, [sender_wallet])

# отправляем транзакцию
txid = client.send_transaction(transaction)
print("Versioned Transaction sent:", txid)

Далее разбираем создание Lookup Table

# Создаем Account Lookup Table
lookup_table = PublicKey("LOOKUP_TABLE_PUBLIC_KEY_HERE")

# моздаем MessageV0 с использованием таблицы
message = MessageV0.try_compile(
    payer=sender_wallet.public_key,
    instructions=[instruction],
    address_lookup_table_accounts=[lookup_table],  # добавляем таблицу
    recent_blockhash = client.get_recent_blockhash()["result"]["value"]["blockhash"],
)

# создаем VersionedTransaction
transaction = VersionedTransaction(message, [sender_wallet])

вот такая солана изнутри, более подробно расписываю в гайде 🪙

😞 МЕМ-КОИНС на солана | гасимся

начнем с торгов на радиум, далее посмотрим памп-фан

через апишку будем мониторить цены и объем + покупка / продажа

pip install solana websockets requests

Мониторим цены

import requests

def get_price(token_address):
    url = f"https://api.raydium.io/v1/token/{token_address}"
    response = requests.get(url)
    data = response.json()
    return data.get("price")

🎮 Отслеживание Пампа (изменения объема)

    url = f"https://api.raydium.io/v1/token/{token_address}"
    response = requests.get(url)
    data = response.json()
    volume = data.get("volume")

    if volume > threshold_volume:
        return True
    return False

💰 Автоматическая покупка

def buy_token(wallet, token_address, amount):
    # создание транзакции
    transaction = Transaction().add(
        transfer(TransferParams(
            from_pubkey = wallet.public_key(),
            to_pubkey = PublicKey(token_address),
            lamports = amount)
    )
    # подпись и отправка транзакции
    client.send_transaction(transaction, wallet)

⬇️ Автоматическая продажа

def sell_token(wallet, token_address, amount):
    # аналогично покупке, но с продажей
    transaction = Transaction().add(
        transfer(TransferParams(
            from_pubkey = wallet.public_key(),
            to_pubkey = PublicKey(token_address),
            lamports = amount)
    )
    client.send_transaction(transaction, wallet)

👁 все кратко, скрипт будет намного больше и подробнее, все пишу в статью по солане

Дайте актива, дропнем статью быстрее 🥰

+ В Скрипт можно добавить оправку пампов в тг и дискорд

😱 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()

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

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

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