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

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

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

Счета (Accounts) 💰

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

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

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

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

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

Асинхронные запросы в 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

# подключаемся к 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)

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

# генерим 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)

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

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

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

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

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

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

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

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

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

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

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

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

Вместо этого можно подписываться на события через 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())

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

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)

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

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

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

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

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

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

Задачи 👍

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

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

Прежде чем транзакция попадет в блок, она отправляется в 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.

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? 🤬

> 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")

Rust обеспечивает memory safety без необходимости в garbage collector (GC), что критически важно для блокчейнов, где даже небольшие задержки могут приводить к высокому расходу газа или уязвимостям.

🔧 Rust сочетает безопасность памяти (как в Solidity) с высокой производительностью без GC (как C++), что делает его идеальным для блокчейнов.

На Rust можно разрабатывать не только смарт-контракты, но и:

> DeFi-приложения (Solana, NEAR)

> Layer-2 решения (ZK-rollups, state channels)

> Блокчейн-клиенты (Ethereum, Polkadot)

> Боты для арбитража и трейдинга

> Криптографические библиотеки (шифрование, подписи)

WEB3 X Rust 😮

ethers-rs - Web3-клиент для Ethereum и EVM-совместимых блокчейнов.
(подписывать и отправлять транзакции, взаимодействовать с контрактами)

solana-sdk - Библиотека для работы с Solana.
(писать программы и управлять аккаунтами)

substrate-api-client - Rust API для работы с Polkadot/Substrate.
(управления узлами и контрактами)

use ethers::prelude::*;
use std::convert::TryFrom;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = Provider::<Http>::try_from("https://mainnet.infura.io/v3/INFURA_KEY")?;
    
    let address: Address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e".parse()?;
    let balance = provider.get_balance(address, None).await?;

    println!("Баланс: {} ETH", balance);
    Ok(())
}

use ethers::prelude::*;
use std::convert::TryFrom;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = Provider::<Http>::try_from("https://mainnet.infura.io/v3/INFURA_KEY")?;
    let wallet: LocalWallet = "PRIVATE_KEY".parse::<LocalWallet>()?.with_chain_id(1);
    let client = SignerMiddleware::new(provider.clone(), wallet);

    let to: Address = "0xRecipientAddressHere".parse()?;
    let tx = TransactionRequest::new()
        .to(to)
        .value(ethers::utils::parse_ether(0.01)?) // 0.01 ETH
        .gas_price(provider.get_gas_price().await?);

    let pending_tx = client.send_transaction(tx, None).await?;
    let tx_hash = pending_tx.tx_hash();

    println!("Отправлено! Tx hash: {:?}", tx_hash);
    Ok(())
}

USDT - 0xdAC17F958D2ee523a2206206994597C13D831ec7

use ethers::prelude::*;
use std::convert::TryFrom;
use tokio;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let provider = Provider::<Http>::try_from("https://mainnet.infura.io/v3/INFURA_KEY")?;
    
    let erc20 = "0xdAC17F958D2ee523a2206206994597C13D831ec7".parse::<Address>()?;
    let user = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e".parse::<Address>()?;

    let abi: Abi = serde_json::from_str(include_str!("erc20_abi.json"))?;
    let contract = Contract::new(erc20, abi, provider.clone());

    let balance: U256 = contract.method("balanceOf", user)?.call().await?;
    println!("Баланс USDT: {} USDT", balance);
    Ok(())
}

1⃣ Берем любой популярный web3 проект - Ethers.js, Hardhat, Foundry, Solidity, Ethereum, L2-решений

2⃣ Заходим в issue, смотрим, какие задачи можно решить.

3⃣ Читаем чужой код - понимаем, как работают крупные проекты.

4⃣ Контрибь – попадаешь на радары.

Пилить DeFi-контракты, арбитражных ботов, NFT-дропы, L2-плагины. ⬇️

> Расписывать процесс разработки в тредах в Twitter / писать посты в Telegram.

> Делать видосы – записывай свой код с объяснением.

Я написал арбитражного бота на Python -> выложил GitHub + Telegram пост -> Кто-то увидел -> предложил контракт или работу 🤬

Gitcoin, ETHGlobal, Encode Club - хакатоны и гранты

🤬 Arbitrum, Optimism, Polygon, zkSync - у всех есть гранты для разработчиков.

Участвуем в обсуждениях в Discord/Twitter/Telegram у топовых криптопроектов

Заходим в Lens, Farcaster, Warpcast - новые соцсети для крипторазработчиков 🤳

Questbook - гранты, задания.

Cryptojobslist - площадка с вакансиями и фриланс-заказами в крипто.

🐺 Ethlance - децентрализованная фриланс-биржа на Ethereum.

LaborX – платформа с крипто-оплатами в USDT, ETH etc.

CryptoJobsList, Remote3, Web3.career - доски вакансий

🤫 Discord серверы Solana, Ethereum, zkSync, Polygon, Starknet - ИЩЕМ "we're hiring".

🐈 Pet-project - личный (не коммерческий) проект, который ты создаешь для изучения технологий, прокачки навыков и создания портфолио.

Создаем DApp, которое подключается к кошельку (MetaMask, WalletConnect) и показывает баланс токенов, стейкинг, доходность фарминга, транзакции и другие метрики 💻

Технологии: TypeScript, Next.js, Ethers.js / Viem, The Graph

💰 Фичи:

> Автоподключение к кошельку

> История транзакций

> Анализ доходности

> Поддержка нескольких сетей

⌚️ Бот, отслеживает новые NFT-аукционы на OpenSea / Blur и уведомляет пользователя о самых перспективных лотах.

Python (Web3.py), Solidity, OpenSea API, Telegram Bot API

💪 Фичи:

> Подключение к NFT-маркетплейсам

> Оценка ликвидности коллекций

> Автоматическое размещение ставок

> Уведомления в Telegram

🤫 Чат, где можно отправлять сообщения и платить за них криптой.

Solidity, React, IPFS, WalletConnect

Фичи:

> Отправка сообщений через IPFS

> Оплата через smart-contract

> Поддержка ENS 🪙

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

Solidity (Governor контракт), React, Ethers.js, Hardhat

☕️ Фичи:

> Поддержка голосования на основе токенов

> Гибкие правила голосования

> Подключение к Snapshot / Aragon

🤬 Маркетплейс для игровых NFT с возможностью P2P-торговли и ставок.

🤣 Solidity (ERC-721 / ERC-1155), Next.js, IPFS, The Graph

Фичи:

> Выставление NFT на продажу

> On-chain аукционы

> Подключение к OpenSea

Изучение технологий - прокачиваем Solidity, Ethers.js, Web3.py, Hardhat, Foundry и другие инструменты 🥤

💼 Создание портфолио - можно показать работодателю или инвесторам

🤩 Развитие идеи - успешный pet-project можно превратить в стартап.

Проверка концепции - можем тестировать новые механики, например, новые модели токеномики 🎉

как работать с web3.py и получать информацию из блокчейна? 😑

Устанавливаем web3.py

> Подключаемся к публичному RPC-узлу (Infura или Alchemy)

> Получаем информацию о блоках, балансе кошельков и истории транзакций

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

> Создаем и подписываем транзакцию с помощью web3.py

> Отправь тестовые ETH на Goerli или Sepolia

> Пробуем взаимодействовать с любым смарт-контрактом

🥊 читаем события из блокчейна и работаем с историей транзакций.

> Подключаемся к WebSocket-узлу Ethereum для реального времени

> Пишем Python-скрипт для мониторинга новых блоков и транзакций

> Фильтруем транзакции по адресу, токенам или конкретным контрактам

> Парсим события (logs) из смарт-контрактов (например, переводы токенов ERC-20)

Получаем информацию о ценах криптовалют с CEX и DEX ✏️

> Подключаемся к API Binance, OKX, KuCoin (CEX)

> Получаем данные о ценах токенов и объёме торгов

> Подключаемся к Uniswap или 1inch API для получения цен на DEX

> Реализовываем мониторинг скачков цен и анализ спредов между биржами

Автоматическое отслеживание значительных изменений цен 😭

> Подключиться к нескольким биржам (CEX + DEX)

> Реализовать логику уведомления при изменении цены > X% за Y секунд

> Реализовать Telegram-бота для отправки уведомлений

Добавить функционал, например: просмотр цены по запросу 👊

Подключаемся к смарт-контракту ERC-721 или ERC-1155

> Получаем данные о NFT (метаданные, владелец, историю транзакций)

> Отправляем NFT другому пользователю

> Читаем события (Transfer) из NFT-контрактов

ТУЛЗ 👍

Web3.py – работа с Ethereum (чтение данных, транзакции)

IPFS / Pinata – хранение метаданных NFT

Etherscan API – получение истории транзакций

> Подключаемся к Uniswap V3 (PancakeSwap или 1inch)

> Получаем ликвидность, цены и объемы

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

> Мониторим цены и автоматически исполненяем сделки

ТУЛЗ 🤩

Web3.py – взаимодействие с контрактами

Uniswap V3 SDK / 1inch API – свопы и цены

AIOHTTP / Asyncio – асинхронные запросы

Ищем разницу цен и совершаем прибыльные сделки 🎧

> Подключаемся к нескольким DEX и CEX

> Расчитываем спред между биржами

> Автоматически исполненяем арбитражные сделки

> Работаем с flash-loan (по желанию)

ТУЛЗ 😱

CCXT - API для CEX (Binance, OKX, KuCoin)

Web3.py – подключение к DEX (Uniswap, PancakeSwap)

Pandas/Numpy – расчет спредов

Flashbots – для арбитража с flash-loans

> Мониторинг мемпула и поиск выгодных транзакций

> Написание снайпер-бота для покупки новых токенов

> Фронтраннинг (опционально)

ТУЛЗ 💃

Web3.py + Etherscan API – анализ транзакций

Infura / Alchemy – доступ к мемпулу

Flashbots – отправка приоритетных транзакций