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

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

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

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

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

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

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)

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

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

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

Powered by ⚡️ Astrum

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)