Initial import: shine + solana-shine-client-lib

shine/.gitignore

@@ -0,0 +1,9 @@
+.anchor
+.DS_Store
+target
+**/*.rs.bk
+node_modules
+test-ledger
+.yarn
+program-keypair.json
+/old_vers/

shine/.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

shine/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/shine.iml" filepath="$PROJECT_DIR$/.idea/shine.iml" />
+    </modules>
+  </component>
+</project>

shine/.idea/shine.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/programs/shine/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

shine/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

shine/.prettierignore

@@ -0,0 +1,7 @@
+.anchor
+.DS_Store
+target
+node_modules
+dist
+build
+test-ledger

shine/AGENTS.md

@@ -0,0 +1,9 @@
+# AGENTS.md
+
+## Documentation Rule
+
+В проекте есть спецификация пользовательской PDA-записи:
+
+- `doc/SHINE_USER_PDA_V1.md`
+
+Если меняется формат записи, сериализация, правила подписи, `prev_hash`, экономика лимитов или связанные ограничения create/update, этот документ нужно обновлять в том же изменении.

shine/Anchor.toml

@@ -0,0 +1,39 @@
+[toolchain]
+package_manager = "yarn"
+
+[features]
+resolution = true
+skip-lint = false
+
+[programs.localnet]
+shine_users = "5dFcWDNp42Xn9Vv4oDMJzM4obBJ8hvDuAtPX54fT5L3t"      #тут надо если что обновлять
+shine_payments = "92sgkgx7KHpbhQu81mNGHaKa7skJB7esArVdPM7paDSW"          #тут надо если что обновлять
+
+
+[programs.devnet]
+shine_users = "5dFcWDNp42Xn9Vv4oDMJzM4obBJ8hvDuAtPX54fT5L3t"            #тут надо если что обновлять
+shine_payments = "92sgkgx7KHpbhQu81mNGHaKa7skJB7esArVdPM7paDSW"              #тут надо если что обновлять
+
+
+[workspace]
+members = [
+    "programs/shine_users",
+    "programs/shine_payments",
+]
+
+[registry]
+url = "https://api.apr.dev"
+
+[provider]
+cluster = "devnet"#"http://127.0.0.1:8899"                      # это в какую сеть деплоит по умолчанию
+wallet = "~/.config/solana/id.json"     # а это с какого кошелько спишутся средства за деплой
+
+[scripts]
+test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"
+
+
+
+
+
+
+

shine/Cargo.toml

@@ -0,0 +1,25 @@
+[workspace]
+members = [
+    "programs/common",
+    "programs/shine_users",
+    "programs/shine_payments",
+]
+resolver = "2"
+
+[profile.release]
+overflow-checks = true
+lto = "fat"
+codegen-units = 1
+[profile.release.build-override]
+opt-level = 3
+incremental = false
+codegen-units = 1
+
+
+
+
+
+
+
+
+

shine/doc/Deploy.txt

@@ -0,0 +1,31 @@
+Деплой в devnet (по умолчанию у тебя уже devnet):
+           обе программы сразу:
+anchor deploy
+           или по одной:
+anchor deploy --program-name shine_users
+anchor deploy --program-name shine_payments
+
+ Проверка деплоя
+anchor keys list
+solana program show 5dFcWDNp42Xn9Vv4oDMJzM4obBJ8hvDuAtPX54fT5L3t       // <ID_из_shine_users-keypair.json>
+solana program show GcGFR47xF7o7ztXzN4MFThmxzHn4z6VmpmELgNk8smCm       // <ID_из_shine_payments-keypair.json>
+
+ Апгрейд в будущем
+ После изменений кода:
+anchor build
+anchor upgrade --program-name shine_users
+anchor upgrade --program-name shine_payments
+
+ посмотреть адрес кошелька
+ solana address -k /home/ai/.config/solana/id.jsonanchor build --program-name shine_payments
+
+
+
+
+
+
+anchor deploy --program-name shine_payments
+
+solana program show  92sgkgx7KHpbhQu81mNGHaKa7skJB7esArVdPM7paDSW --url http://127.0.0.1:8899
+
+solana address -k /home/ai/work/SOLANA/shine/target/deploy/shine_payments-keypair.json

shine/doc/READ_ME.txt

@@ -0,0 +1,39 @@
+# подключаться надо к
+JSON RPC URL: http://127.0.0.1:8899
+
+# Запустить саму ноду
+solana-test-validator
+# Удалить процесс ноды что бы запустить заново
+kill -9 $(pgrep -f "solana-test-validator")
+
+или
+ps aux | grep solana-test-validator
+а потом
+kill -9 1052345
+# Убивает и логи и всю базу локальной ноды
+rm -rf test-ledger
+
+
+# Удалить все данные с ноды
+solana-test-validator --reset
+
+
+# Что бы запустить просмотр логов ноды
+solana logs
+
+# Запустить контракт
+anchor deploy
+
+# Cкомпилировать и задеплоить новую версию
+anchor build                     # Скомпилировать контракт и сгенерировать IDL
+anchor deploy                    # Задеплоить контракт в сеть (указанную в Anchor.toml)
+Если ты хочешь сразу убедиться, куда он деплоится — проверь Anchor.toml.
+[provider]
+cluster = "https://api.testnet.solana.com"  # или "localnet"
+wallet = "~/.config/solana/id.json"
+
+
+
+
+# Создать новый проект
+anchor init имя_проекта

shine/doc/READ_ME_NEW_DEPLOY.txt

@@ -0,0 +1,65 @@
+https://api.devnet.solana.com
+
+
+проверить настройки
+solana config get
+
+настроить
+solana config set --url https://api.devnet.solana.com
+или
+solana config set --url http://127.0.0.1:8899
+
+потом
+solana airdrop 2 --keypair /home/ai/.config/solana/id.json
+и
+solana balance --keypair /home/ai/.config/solana/id.json
+
+
+
+anchor deploy \
+  --provider.cluster https://api.devnet.solana.com \
+  --provider.wallet /home/ai/.config/solana/id.json
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Шаг 1. Создай новый ключ для новой программы
+
+solana-keygen new --outfile target/deploy/user_registry-testnet-keypair.json
+
+Шаг 2. Укажи новый ID в declare_id!:
+
+declare_id!("НОВЫЙ_PUBKEY_ОТСЮДА"); // получен из предыдущей команды
+
+Чтобы узнать pubkey:
+
+solana address -k target/deploy/user_registry-testnet-keypair.json
+
+Шаг 3. Обнови Anchor.toml:
+
+[programs.testnet]
+user_registry = "НОВЫЙ_PUBKEY"
+
+[provider]
+cluster = "https://api.testnet.solana.com"
+wallet = "~/.config/solana/id.json"
+
+Шаг 4. Компиляция и деплой:
+
+anchor build
+anchor deploy --provider.cluster testnet
+
+Шаг 5. Проверка:
+
+solana program show НОВЫЙ_PUBKEY --url https://api.testnet.solana.com

shine/doc/ReadMe.md

@@ -0,0 +1 @@
+Просто разные заметки для себя

shine/doc/SHINE_USER_PDA_V1.md

@@ -0,0 +1,144 @@
+# SHiNE User PDA v1.0
+
+## 1. Назначение
+
+`SHiNE User PDA v1.0` — бинарный формат пользовательской записи в PDA Solana.
+
+Хранит:
+- логин;
+- ключи пользователя;
+- номер внутренней сети;
+- лимит (баланс);
+- серверные данные (опционально);
+- список серверов подключения;
+- данные восстановления;
+- связь с предыдущей версией через `prev_hash`;
+- подпись владельца `root_key`.
+
+Размер PDA фиксированный:
+
+`768 bytes`
+
+Полезная длина записи указывается в `record_len`.
+
+## 2. Общие правила кодирования
+
+- Числа: `little-endian`.
+- Строки: `UTF-8` с префиксом длины `u8`.
+- Padding до 768 байт: нули `0x00`.
+- Padding не входит в `record_len`.
+
+## 3. Структура записи
+
+- `magic` (5): `"SHiNE"`
+- `format_major` (1): `1`
+- `format_minor` (1): `0`
+- `record_len` (2): длина от `magic` до `signature` включительно
+- `created_at_ms` (8)
+- `updated_at_ms` (8)
+- `version` (4)
+- `prev_hash` (32)
+- `login_len` (1)
+- `login` (N)
+- `root_key` (32)
+- `blockchain_key` (32)
+- `device_key` (32)
+- `chain_number` (2)
+- `balance` (8)
+- `is_server` (1)
+- если `is_server=1`:
+  - `server_key` (32)
+  - `server_address_len` (1)
+  - `server_address` (N)
+- `connection_servers_count` (1)
+- повтор `count` раз:
+  - `server_login_len` (1)
+  - `server_login` (N)
+- `trusted_count` (1)
+- `reserved` (5) = `0x00 0x00 0x00 0x00 0x00`
+- `signature` (64)
+- `padding` до 768
+
+## 4. Подпись (v1.0)
+
+В `v1.0` подписывается не сырой блок полей напрямую, а его SHA-256.
+
+1. Формируется `unsigned_bytes`:
+   - все поля от `magic` до `reserved` включительно;
+   - поле `signature` не включается;
+   - padding не включается.
+2. Считается `msg_hash = SHA-256(unsigned_bytes)`.
+3. `signature = Ed25519.sign(root_private_key, msg_hash)`.
+4. Проверка:
+   - `Ed25519.verify(root_key, msg_hash, signature)`.
+
+## 5. Что входит в `prev_hash`
+
+Для связи версий:
+
+- `prev_hash = SHA-256(previous_unsigned_bytes)`
+
+Где `previous_unsigned_bytes` — предыдущая версия записи от `magic` до `reserved` включительно, без `signature` и без padding.
+
+Для первой версии:
+
+- `prev_hash = 32` нулевых байта.
+
+## 6. Правила create/update в текущей реализации
+
+### Create
+
+- PDA: seed `["login=", login]`.
+- Создаётся запись версии `0`.
+- `updated_at_ms = created_at_ms`.
+- Стартовый лимит:
+  - `START_BONUS_LIMIT + additional_limit`.
+- Оплата:
+  - регистрационная комиссия;
+  - пополнение `additional_limit` по курсу;
+  - рента PDA (плательщик транзакции).
+
+### Update
+
+- Проверка подписи новой записи по `root_key`.
+- Проверка:
+  - `magic`, `format_major`, `format_minor`;
+  - корректного `record_len`;
+  - `prev_hash` на соответствие предыдущей версии;
+  - `version = old_version + 1`;
+  - неизменяемых полей: `login`, `created_at_ms`, `root_key`.
+- `balance` не уменьшается:
+  - `new_balance = old_balance + additional_limit`.
+- При `additional_limit > 0` берётся комиссия пополнения.
+
+## 7. Параметры экономики/размера (settings)
+
+См. `programs/shine_users/src/settings.rs`:
+
+- `USER_PDA_SPACE = 768`
+- `REGISTRATION_FEE_RECEIVER`
+- `REGISTRATION_FEE_LAMPORTS`
+- `LIMIT_STEP`
+- `LAMPORTS_PER_LIMIT_STEP`
+- `START_BONUS_LIMIT`
+
+## 8. Root Key Rotation (пока не включено)
+
+В `v1.0` `root_key` неизменяем.
+
+Варианты расширения:
+
+1. **Dual-signature rotate tx**:
+   - отдельный флаг операции rotate;
+   - запись подписывается и старым, и новым root key;
+   - контракт проверяет обе подписи.
+
+2. **Two-step commit/confirm**:
+   - шаг 1: proposal смены root (`old root` подпись);
+   - шаг 2: confirm (`new root` подпись) в отдельной tx.
+
+3. **Recovery guardians**:
+   - отдельная PDA для доверенных лиц;
+   - пороговая схема (например `m-of-n`) для восстановления root.
+
+Для v1.0 решение отложено, но изменение root_key в update запрещено.

shine/doc/TODO

@@ -0,0 +1,7 @@
+. Сделать новые форматы для пользователей что бы там было больше информации
+
+. Протестировать работу и может доработать что бы можно было паралельно регистрировать 5 и более юзеров - за счёт передачи при вызове адресов PDA +1 +2 +3 +4  и т.д.
+
+
+
+. - пока не надо - Сделать что бы в файле общей информации добавилась запись для будущей миграции пользователей (хотя можно потом и добавить будет :)))

shine/doc/how to getback money after deploy from buffer.txt

@@ -0,0 +1,19 @@
+Как вернуть деньги
+
+    Узнаём адрес buffer account:
+
+solana program show <адрес_твоей_программы>
+
+Там будет строчка Buffer: <PUBKEY>.
+
+Закрываем буфер:
+
+    solana program close <PUBKEY> --recipient <адрес_кошелька>
+
+    💡 --recipient — это куда вернуть SOL (обычно твой же кошелёк из ~/.config/solana/id.json).
+
+Сколько вернётся
+
+    Если бинарник весит ~400 KB, с одного буфера вернётся ~0.35 SOL.
+
+    У тебя две программы (shine_users, shine_payments), значит можно вернуть ~0.7 SOL.

shine/doc/how todo minimal size.txt

@@ -0,0 +1,6 @@
+✅ Чтобы максимально уменьшить .so надо будет включить флаг оптимизации в Cargo.toml:
+
+[profile.release]
+opt-level = "z"        # Максимальная компрессия
+lto = true             # Link Time Optimization
+codegen-units = 1      # Уменьшает размер бинаря

shine/doc/sh/restart.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+set -e  # Завершаем при ошибке
+set -o pipefail
+
+
+
+
+
+PROGRAM_KEYPAIR="target/deploy/shine-keypair.json"  # замени на свой путь
+WALLET=$(solana address)
+
+echo "🧹 Удаление старого ledger..."
+rm -rf test-ledger
+
+echo "🚀 Запуск solana-test-validator в фоне..."
+solana-test-validator --ledger test-ledger --reset > validator.log 2>&1 &
+VALIDATOR_PID=$!
+
+# Убедимся, что validator запущен
+echo "⏳ Ожидание запуска валидатора..."
+until solana cluster-version &>/dev/null; do
+  sleep 1
+done
+sleep 2  # На всякий случай немного подождём
+
+echo "💸 Airdrop 10 SOL на $WALLET..."
+solana airdrop 10 HMww7YSVfwVm4i8sugqj7wyH26dqzHykzv3wzWwzEvPA
+
+solana airdrop 5 $WALLET
+
+echo "🔨 Сборка контракта..."
+anchor build
+
+echo "📦 Деплой контракта..."
+anchor deploy
+
+echo "✅ Готово!"
+
+# Не убиваем валидатор, чтобы он оставался запущенным
+echo "ℹ️ Валидатор всё ещё работает (PID $VALIDATOR_PID)"
+
+echo "ℹ️ Запускаем логи"
+solana logs

shine/doc/sh/stop.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+set -e  # Завершаем при ошибке
+set -o pipefail
+
+
+kill -9 $(pgrep -f "solana-test-validator")
+
+# 🔍 Ищем запущенный solana-test-validator
+EXISTING_PID=$(pgrep -f "solana-test-validator")
+
+if [ -n "$EXISTING_PID" ]; then
+  echo "🛑 Найден работающий solana-test-validator (PID $EXISTING_PID), останавливаем..."
+  bash kill -9 $(pgrep -f "solana-test-validator")
+  echo "✅ Пытаюсь остановить старый валидатор..."
+
+  # ждём завершения
+  while kill -0 "$EXISTING_PID" 2>/dev/null; do
+    sleep 0.5
+  done
+  echo "✅ Старый валидатор остановлен."
+fi
+

shine/doc/что содержит utils.txt

@@ -0,0 +1,145 @@
+Функции для работы с PDA:
+
+
+🧩 create_pda(...)
+
+    Создаёт новый PDA, если он ещё не существует.
+
+    Проверяет, чтобы не было коллизии.
+
+    Без записи данных.
+
+🧩 write_to_pda(...)
+
+    Просто записывает байты в существующий PDA.
+
+    Без создания.
+
+🧩 create_and_write_pda(...)
+
+    Комбинированная функция.
+
+    Сначала проверяет, есть ли PDA — если нет, создаёт.
+
+    Затем записывает данные.
+
+    Очень удобна для инициализации одного PDA в один вызов.
+
+🧩 safe_read_pda(...)
+
+    Возвращает Vec<u8> с содержимым PDA.
+
+    Никогда не паникует: если PDA не существует или пустой — просто отдаёт Vec::new().
+
+    Защита от двойного borrow'а (через try_borrow_data()).
+
+    Отличный инструмент для безопасного считывания данных.
+
+💡 Да, с этим ты можешь:
+Возможность	Функция
+📦 Создать PDA	create_pda
+💾 Записать в PDA	write_to_pda
+⚡ Создать и записать	create_and_write_pda
+📖 Безопасно прочитать	safe_read_pda
+
+
+🔧 create_pda(...)
+
+🔹 Назначение:
+Создаёт новый PDA-аккаунт, если он ещё не существует.
+
+📥 Аргументы:
+
+    pda_account: &AccountInfo — аккаунт, который хотим создать
+
+    signer: &AccountInfo — аккаунт плательщика (обычно пользователь)
+
+    system_program: &AccountInfo — системная программа
+
+    program_id: &Pubkey — адрес текущей программы
+
+    seeds: &[&[u8]] — массив сидов, по которым создавался PDA
+
+    space: u64 — сколько байт выделить под данные
+
+📤 Возвращает:
+
+    Result<()> — Ok если успешно, Err если PDA уже существует или при ошибке создания
+
+🧠 Особенности:
+
+    Проверяет, что PDA ещё не создан (через pda_account.owner == Pubkey::default())
+
+    Выбрасывает ErrCode::PdaAlreadyExists, если уже существует
+
+🔧 write_to_pda(...)
+
+🔹 Назначение:
+Записывает бинарные данные в существующий PDA.
+
+📥 Аргументы:
+
+    pda_account: &AccountInfo — аккаунт, в который пишем
+
+    data: &[u8] — массив байт, которые нужно записать
+
+📤 Возвращает:
+
+    Result<()> — Ok при успехе, Err если не удалось получить доступ к данным
+
+🧠 Особенности:
+
+    ⚠️ Только пишет, не создаёт PDA
+
+    Записывает в начало data-секции аккаунта
+
+🔧 create_and_write_pda(...)
+
+🔹 Назначение:
+Если PDA ещё не существует — создаёт, затем сразу записывает данные.
+
+📥 Аргументы:
+
+    pda_account: &AccountInfo — аккаунт для создания/записи
+
+    signer: &AccountInfo — кто оплачивает создание
+
+    system_program: &AccountInfo — системная программа
+
+    program_id: &Pubkey — адрес текущей программы
+
+    seeds: &[&[u8]] — сиды PDA
+
+    data: Vec<u8> — данные для записи
+
+    space: u64 — сколько байт выделить (при создании)
+
+📤 Возвращает:
+
+    Result<()> — Ok при успехе, Err при ошибке создания или записи
+
+🧠 Особенности:
+
+    Безопасно создаёт и пишет за один вызов
+
+    Не выбрасывает ошибку, если PDA уже существует — просто пишет
+
+🔧 safe_read_pda(...)
+
+🔹 Назначение:
+Безопасно считывает байты из PDA. Никогда не паникует.
+
+📥 Аргументы:
+
+    pda_account: &AccountInfo — аккаунт для чтения
+
+📤 Возвращает:
+
+    Vec<u8> — массив байт с содержимым PDA
+    → Если аккаунт не инициализирован или пустой, возвращает Vec::new()
+
+🧠 Особенности:
+
+    Не выбрасывает ошибки — только логирует
+
+    Полностью безопасно: подходит для чтения read-only PDA в любой ситуации

shine/migrations/deploy.ts

@@ -0,0 +1,12 @@
+// Migrations are an early feature. Currently, they're nothing more than this
+// single deploy script that's invoked from the CLI, injecting a provider
+// configured from the workspace's Anchor.toml.
+
+import * as anchor from "@coral-xyz/anchor";
+
+module.exports = async function (provider: anchor.AnchorProvider) {
+  // Configure client to use the provider.
+  anchor.setProvider(provider);
+
+  // Add your deploy script here.
+};

shine/mu.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Кол-во адресов для генерации
+NUM_KEYS=5
+
+# RPC endpoint (можешь поменять)
+#RPC_URL="https://api.testnet.solana.com"
+RPC_URL="http://127.0.0.1:8899"
+
+echo "👉 Используем RPC: $RPC_URL"
+
+for i in $(seq 1 $NUM_KEYS); do
+  KEYPAIR="temp-key-$i.json"
+  echo "🔐 Генерирую ключ №$i: $KEYPAIR"
+  solana-keygen new --outfile "$KEYPAIR" --no-bip39-passphrase --silent
+
+  PUBKEY=$(solana-keygen pubkey "$KEYPAIR")
+  echo "🪙 Публичный ключ: $PUBKEY"
+
+  echo "💸 Запрашиваю airdrop на $PUBKEY..."
+  solana airdrop 1 "$PUBKEY" --url "$RPC_URL"
+
+  echo "🔍 Проверяю баланс:"
+  solana balance "$PUBKEY" --url "$RPC_URL"
+  echo "-----------------------------"
+done
+
+echo "✅ Готово. Удаляю временные ключи..."
+rm temp-key-*.json

shine/package.json

@@ -0,0 +1,20 @@
+{
+  "license": "ISC",
+  "scripts": {
+    "lint:fix": "prettier */*.js \"*/**/*{.js,.ts}\" -w",
+    "lint": "prettier */*.js \"*/**/*{.js,.ts}\" --check"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1"
+  },
+  "devDependencies": {
+    "chai": "^4.3.4",
+    "mocha": "^9.0.3",
+    "ts-mocha": "^10.0.0",
+    "@types/bn.js": "^5.1.0",
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.0.0",
+    "typescript": "^5.7.3",
+    "prettier": "^2.6.2"
+  }
+}

shine/programs/common/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "common"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anchor-lang = "0.31.1"
+
+
+[features]

shine/programs/common/src/lib.rs

@@ -0,0 +1 @@
+pub mod utils;

shine/programs/common/src/utils.rs

@@ -0,0 +1,402 @@
+use anchor_lang::prelude::*;
+use anchor_lang::solana_program::{
+    program::invoke_signed,
+    system_instruction,
+    system_program
+};
+
+
+
+
+
+
+/// сдесь коды всех ошибок 
+
+#[error_code]
+pub enum ErrCode {
+    /// Система уже инициализирована и не может быть инициализирована повторно!
+    #[msg("Система уже инициализирована и не может быть инициализирована повторно!")]
+    SystemAlreadyInitialized = 1000,
+    
+    #[msg("PDA не содержит данных или не инициализирован")]
+    EmptyPdaData = 1002,
+
+    #[msg("Пользователь уже зарегистрирован")]
+    UserAlreadyExists = 1003,
+
+    #[msg("Некорректный логин")]
+    InvalidLogin = 1004,
+
+    #[msg("Не совпадает PDA адрес")]
+    InvalidPdaAddress = 1006,
+
+    #[msg("Формат данных не поддерживается")]
+    UnsupportedFormat = 1011,
+
+    #[msg("Ошибка при десериализации")]
+    DeserializationError = 1012,
+
+    /// PDA уже существует, создание невозможно
+    #[msg("PDA-аккаунт уже существует и не может быть создан повторно.")]
+    PdaAlreadyExists = 1009,
+
+
+    #[msg("Подписавший не совпадает с ожидаемым пользователем (это потому что пока временно можно регистрировать пользователя с другово аккаунта")]
+    InvalidSigner = 1005,
+
+    /// Не получилось создат ьпользователя, система уже перегружена, попробуйте поззже!"
+    #[msg("Не получилось создать пользователя, система уже перегружена, попробуйте поззже!")]
+    NoSuitableIdPda = 1010,
+
+    #[msg("Невалидная цифровая подпись записи")]
+    InvalidSignature = 1013,
+
+    #[msg("Невалидный формат записи")]
+    InvalidRecordFormat = 1014,
+
+    #[msg("Невалидная длина записи")]
+    InvalidRecordLength = 1015,
+
+    #[msg("Невалидные данные записи")]
+    InvalidRecordData = 1016,
+
+    #[msg("Невалидный хэш предыдущей версии")]
+    InvalidPrevHash = 1017,
+
+    #[msg("Попытка изменить неизменяемое поле")]
+    ImmutableFieldChanged = 1018,
+
+    #[msg("Попытка уменьшить лимит/баланс")]
+    BalanceDecrease = 1019,
+
+    #[msg("Невалидная версия записи")]
+    InvalidVersion = 1020,
+
+    #[msg("Размер записи превышает допустимый")]
+    RecordTooLarge = 1021,
+
+    #[msg("Переполнение при вычислении")]
+    MathOverflow = 1022,
+
+    #[msg("Неверный адрес получателя комиссии")]
+    InvalidFeeReceiver = 1023,
+
+    #[msg("Пополнение лимита должно быть кратно шагу")]
+    InvalidLimitIncrement = 1024,
+
+    #[msg("Невалидная magic-сигнатура записи")]
+    InvalidRecordMagic = 1025,
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+///----------------------------------------------------------------------------------------------------------
+///                        Базовые функции для работы с PDA
+///----------------------------------------------------------------------------------------------------------
+
+/// Создаёт PDA аккаунт (если его ещё нет), и записывает в него массив байт.
+///
+/// Аргументы:
+/// - `pda_account`: аккаунт, куда записываем
+/// - `signer`: кто платит за создание (обычно пользователь)
+/// - `program_id`: адрес текущей программы
+/// - `seeds`: слайс сидов, по которым создавался PDA
+/// - `data`: байты для записи
+/// - `space`: желаемый размер аккаунта
+pub fn create_and_write_pda<'info>(
+    pda_account: &AccountInfo<'info>,
+    signer: &AccountInfo<'info>,
+    system_program: &AccountInfo<'info>,
+    program_id: &Pubkey,
+    seeds: &[&[u8]],
+    data: Vec<u8>,
+    space: u64,
+) -> Result<()> {
+    // ───────────────────────────────────────────────
+    // 1. Проверяем, создан ли аккаунт (если нет — owner = default)
+    if pda_account.owner == &Pubkey::default() {
+        msg!("Создаём PDA с размером {} байт", space);
+
+        let space = space; //+ 128; // Добавляется запас под метаданные
+        // Вычисляем необходимую арендную плату
+        let lamports = Rent::get()?.minimum_balance(space as usize);
+
+        // Формируем инструкцию
+        let create_instr = system_instruction::create_account(
+            signer.key,
+            pda_account.key,
+            lamports,
+            space,
+            program_id,
+        );
+
+        // Выполняем инструкцию с подписью от PDA
+        invoke_signed(
+            &create_instr,
+            &[
+                signer.clone(),
+                pda_account.clone(),
+                system_program.clone(),
+            ],
+            &[&seeds],
+        )?;
+    }
+
+    // ───────────────────────────────────────────────
+    // 2. Пишем данные в аккаунт
+    let mut account_data = pda_account.try_borrow_mut_data()?;
+
+    let copy_len = std::cmp::min(account_data.len(), data.len());
+    account_data[..copy_len].copy_from_slice(&data[..copy_len]);
+
+    // Если хочешь дополнить оставшееся нулями — раскомментируй:
+    // for i in copy_len..account_data.len() {
+    //     account_data[i] = 0;
+    // }
+
+    msg!("Успешно записано {} байт в PDA", copy_len);
+    Ok(())
+}
+
+
+
+
+/// Создаёт PDA аккаунт (если его ещё нет).
+///
+/// ⚠️ Если аккаунт уже существует, выбрасывается ошибка.
+/// Используется внутри инструкций смарт-контракта.
+///
+/// Аргументы:
+/// - `pda_account`: аккаунт, который хотим создать (PDA)
+/// - `signer`: кто оплачивает создание аккаунта (обычно пользователь)
+/// - `system_program`: системная программа (`111...111`)
+/// - `program_id`: адрес текущей программы (используется для подписи PDA)
+/// - `seeds`: массив сидов, по которым вычислялся PDA
+/// - `space`: желаемый размер аккаунта в байтах (только данных, без метаданных)
+pub fn create_pda<'info>(
+    pda_account: &AccountInfo<'info>,
+    signer: &AccountInfo<'info>,
+    system_program: &AccountInfo<'info>,
+    program_id: &Pubkey,
+    seeds: &[&[u8]],
+    space: u64,
+) -> Result<()> {
+    // ───────────────────────────────────────────────
+    // 1. Проверяем, существует ли аккаунт
+    if pda_account.owner != &Pubkey::default() {
+        // Если владелец не равен Pubkey::default, значит аккаунт уже создан
+        // Возвращаем ошибку с пояснением
+        return Err(error!(ErrCode::PdaAlreadyExists));
+    }
+
+    // ───────────────────────────────────────────────
+    // 2. Логируем, что будем создавать PDA
+    msg!("Создаём PDA-аккаунт на {} байт", space);
+
+    // Добавляем запас под метаданные Solana (примерно 128 байт)
+    let full_space = space;
+
+    // Получаем минимальный баланс для аренды (чтобы аккаунт не удалили)
+    let lamports = Rent::get()?.minimum_balance(full_space as usize);
+
+    // ───────────────────────────────────────────────
+    // 3. Создаём инструкцию system_program для создания аккаунта
+    let create_instr = system_instruction::create_account(
+        signer.key,         // от имени кого
+        pda_account.key,    // для какого PDA
+        lamports,           // сколько лампортов перевести
+        full_space,         // сколько байт выделить
+        program_id,         // кто будет владельцем PDA
+    );
+
+    // ───────────────────────────────────────────────
+    // 4. Выполняем инструкцию с подписью PDA (через сиды)
+    invoke_signed(
+        &create_instr,
+        &[
+            signer.clone(),
+            pda_account.clone(),
+            system_program.clone(),
+        ],
+        &[&seeds], // PDA сиды → для подписи
+    )?;
+
+    Ok(())
+}
+
+/// Записывает массив байт в PDA аккаунт (в начало data-секции).
+///
+/// ⚠️ Убедись, что PDA был передан как `#[account(mut)]`
+/// ⚠️ Эта функция ничего не создаёт, только пишет.
+///
+/// Аргументы:
+/// - `pda_account`: аккаунт, в который пишем (должен быть mut)
+/// - `data`: бинарный массив, который нужно записать
+pub fn write_to_pda<'info>(
+    pda_account: &AccountInfo<'info>,
+    data: &[u8],
+) -> Result<()> {
+    // ───────────────────────────────────────────────
+    // 1. Получаем доступ к данным PDA (на запись)
+    let mut account_data = pda_account.try_borrow_mut_data()?;
+
+    // ───────────────────────────────────────────────
+    // 2. Вычисляем сколько байт реально можно записать
+    // (на случай, если data длиннее, чем выделено место)
+    let copy_len = std::cmp::min(account_data.len(), data.len());
+
+    // ───────────────────────────────────────────────
+    // 3. Копируем данные в аккаунт (с самого начала)
+    account_data[..copy_len].copy_from_slice(&data[..copy_len]);
+
+    // Логируем, сколько байт записано
+    msg!("Успешно записано {} байт в PDA", copy_len);
+
+    Ok(())
+}
+
+
+
+
+
+
+
+
+
+
+/// ------------------------------------------------------------------------
+/// safe_read_pda ‒ «безопасное чтение PDA»
+/// ------------------------------------------------------------------------
+///
+/// * Принимает:   ссылку на `AccountInfo<'info>` PDA-аккаунта.
+/// * Возвращает:  `Vec<u8>` с данными аккаунта.  
+///                Если аккаунта нет или его данные пусты — возвращается `Vec::new()`
+///                длиной 0 байт.
+///
+/// Как работает ───────────────────────────────────────────────────────────
+/// 1. Проверяем, что аккаунт **инициализирован**: у не-инициализированного
+///    owner = Pubkey::default(). Если owner нулевой — сразу отдаём пустой вектор.
+/// 2. Если длина буфера == 0 (Anchor helper `data_is_empty()`), тоже отдаём пустой.
+/// 3. Пытаемся безопасно (`try_borrow_data`) получить ссылку на данные.
+///    - Успех → копируем их в Vec и возвращаем.
+///    - Ошибка (например, конфликт borrow) → логируем и возвращаем пустой Vec.
+///
+/// пример использования 
+/// let raw_bytes = safe_read_pda(&ctx.accounts.readonly_pda);
+/// require!(!raw_bytes.is_empty(), ErrCode::EmptyPdaData);
+/// msg!("Размер считанных данных: {}", raw_bytes.len());
+/// ------------------------------------------------------------------------
+pub fn safe_read_pda<'info>(pda_account: &AccountInfo<'info>) -> Vec<u8> {
+    // ─────────────────────────────────────────────────────────────────────
+    // 1) Аккаунт Н*Е* СУЩЕСТВУЕТ или не инициализирован:
+    // owner == Pubkey::default() (в Solana нулевой owner у пустого счёта)
+    // ─────────────────────────────────────────────────────────────────────
+    if pda_account.owner == &Pubkey::default() {
+        msg!("safe_read_pda: аккаунт не инициализирован ‒ возвращаем пустой массив");
+        return Vec::new(); // []
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // 2) У аккаунта нет данных (длина 0) — тоже считаем «пустым»
+    // ─────────────────────────────────────────────────────────────────────
+    if pda_account.data_is_empty() {
+        msg!("safe_read_pda: у аккаунта data_len == 0 ‒ возвращаем пустой массив");
+        return Vec::new();
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // 3) Пытаемся безопасно забрать буфер данных; ошибки перехватываем
+    // ─────────────────────────────────────────────────────────────────────
+    match pda_account.try_borrow_data() {
+        Ok(data_ref) => {
+            // to_vec() копирует bytes → Vec<u8>, чтобы дальше работать без borrow-лифа
+            data_ref.to_vec()
+        }
+        Err(e) => {
+            // Ошибка при borrow (например, уже есть активное мутабельное заимствование)
+            msg!("safe_read_pda: ошибка borrow_data ({:?}) ‒ возвращаем пустой массив", e);
+            Vec::new()
+        }
+    }
+}
+
+    
+
+
+
+
+/// ------------------------------------------------------------------------
+/// delete_pda_with_assign — закрыть PDA, вернуть ренту и освободить адрес
+/// ------------------------------------------------------------------------
+///
+/// Параметры:
+/// - `pda_account`   : PDA-аккаунт (mut), который закрываем (owned вашей программой)
+/// - `recipient`     : счёт, на который возвращаем лампорты (обычно пользователь)
+/// - `system_program`: системная программа (111...111)
+/// - `program_id`    : Pubkey вашей программы (проверка владельца)
+/// - `seeds`         : сиды PDA (в том же порядке, как при создании), чтобы PDA «подписал» assign
+///
+/// Делает:
+/// 1) Проверяет, что PDA принадлежит вашей программе.
+/// 2) Обнуляет данные и сжимает их до 0 байт (realloc(0)).
+/// 3) Переводит все лампорты PDA на `recipient`.
+/// 4) Делает `assign` владельца на System Program (через `invoke_signed`).
+///
+/// Результат:
+/// — В конце транзакции аккаунт с lamports=0 и data_len=0 будет удалён рантаймом,
+///   владелец = System Program (чисто/ожидаемо).
+/// — В следующей транзакции можно снова создать PDA с тем же сидом.
+/// ------------------------------------------------------------------------
+
+pub fn delete_pda_return_rent<'info>(
+    pda_account: &AccountInfo<'info>,
+    recipient: &AccountInfo<'info>,
+    program_id: &Pubkey,
+) -> Result<()> {
+    // 0) проверки
+    require!(pda_account.owner != &Pubkey::default(), ErrCode::EmptyPdaData);
+    require!(pda_account.owner == program_id, ErrCode::InvalidPdaAddress);
+
+    // 1) Переложить все лампорты с PDA на получателя (мы владелец, это разрешено)
+    let amount = **pda_account.lamports.borrow();
+    if amount > 0 {
+        **recipient.lamports.borrow_mut() = recipient
+            .lamports()
+            .checked_add(amount)
+            .ok_or(ProgramError::InsufficientFunds)?;
+        **pda_account.lamports.borrow_mut() = 0;
+    }
+
+    // 2) Нулим данные (если были)
+    if !pda_account.data_is_empty() {
+        let mut data = pda_account.try_borrow_mut_data()?;
+        for b in data.iter_mut() { *b = 0; }
+    }
+
+    // 3) Сжать до 0 байт
+    pda_account.realloc(0, false)?;
+
+    // Никаких assign/transfer больше не делаем — это надёжнее.
+    msg!("PDA закрыт: рента отправлена на {}", recipient.key);
+    Ok(())
+}
+ 

shine/programs/shine_payments/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "shine_payments"
+version = "0.1.0"
+description = "Payments and investments smart contract"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "shine_payments"
+test = false
+doctest = false
+bench = false
+
+[dependencies]
+anchor-lang = "0.31.1"
+common = { path = "../common" }
+
+# ==== добавлено для NFT-функционала ====
+anchor-spl = { version = "0.31.1", features = ["associated_token", "token"] }
+mpl-token-metadata = "5.1.1"
+spl-token = { version = "4.0.0", features = ["no-entrypoint"] }
+# ======================================
+
+[features]
+default = []
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+anchor-debug = []
+custom-heap = []
+custom-panic = []
+cpi = []
+idl-build = ["anchor-lang/idl-build"]

shine/programs/shine_payments/dApp/copyToServer.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+#  Скрипт для копирования dApp на тестовый сервер
+
+# Настройки
+LOCAL_FILE="init.html"
+REMOTE_USER="aidar"
+REMOTE_HOST="shineup.me"
+REMOTE_PATH="/home/aidar/Docker_server/site/dApp"
+
+# Проверка, что файл существует
+if [ ! -f "$LOCAL_FILE" ]; then
+    echo "Ошибка: файл $LOCAL_FILE не найден."
+    exit 1
+fi
+
+# Копирование файла
+scp "$LOCAL_FILE" "${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PATH}"
+
+# Проверка результата
+if [ $? -eq 0 ]; then
+    echo "Файл успешно загружен на сервер."
+else
+    echo "Ошибка при загрузке файла на сервер."
+    exit 1
+fi
+
+#echo
+#echo "Нажмите Enter, чтобы закрыть..."
+#read

shine/programs/shine_payments/dApp/init.html

@@ -0,0 +1,404 @@
+<!DOCTYPE html>
+<html lang="ru">
+    <head>
+        <meta name="robots" content="noindex, nofollow">
+        <meta charset="UTF-8" />
+    <title>Shine Payments — Phantom demo (devnet, deep logs)</title>
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<style>
+    body { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; padding: 20px; }
+    h1 { font-size: 18px; margin-bottom: 12px; }
+    .row { display: flex; gap: 8px; margin-bottom: 10px; flex-wrap: wrap; }
+    button { padding: 8px 12px; border-radius: 8px; border: 1px solid #ccc; cursor: pointer; }
+    button:hover { background: #f5f5f5; }
+    #log {
+    background: #0a0a0a; color: #d1d5db; padding: 12px; border-radius: 10px;
+    min-height: 220px; max-height: 60vh; overflow: auto; line-height: 1.4; white-space: pre-wrap;
+    box-shadow: inset 0 0 0 1px #222;
+}
+    .muted { color: #6b7280; }
+    .ok { color: #86efac; }
+    .err { color: #fca5a5; }
+
+    /* ——— banner с логотипом и предупреждением ——— */
+    .banner {
+        display: flex; align-items: center; gap: 14px;
+        padding: 12px 14px; margin: 12px 0 18px;
+        border: 1px solid #f1e5a8; border-radius: 12px;
+        background: #fffbe6; color: #7a5d00;
+    }
+    .banner img { width: 44px; height: 44px; border-radius: 8px; flex: 0 0 auto; }
+    .banner .txt { line-height: 1.35; }
+    .banner .txt b { font-weight: 700; }
+    .banner .en { margin-top: 6px; color: #6b7280; font-size: 13px; }
+
+</style>
+</head>
+<body>
+<!-- DEV BANNER (logo + RU/EN notice) -->
+<div class="banner" role="note" aria-label="Dev notice">
+    <img src="./shine_nft_logo_256.png" alt="Shine logo">
+    <div class="txt">
+        <div><b>ВНИМАНИЕ:</b> это тестовая страница для внутренней разработки. Я разбираюсь и пишу смарт-контракт и dApp для будущего токена и тестирую его работу в Devnet и подключение кошелька Phantom. Страница не является рабочим продуктом и предназначена только для внутренних тестов.</div>
+        <div class="en"><b>NOTICE:</b> this is a development test page. I’m building a smart contract and dApp for a future token and testing it on Devnet and Phantom wallet connection. This page is not a live product and is intended for internal testing only.</div>
+    </div>
+</div>
+
+<h1>Shine Payments — Phantom wallet (devnet)</h1>
+
+<div class="row">
+    <button id="btnConnect">Connect Phantom</button>
+    <button id="btnInfo"    disabled>Показать адрес и баланс</button>
+    <button id="btnAirdrop" disabled>Airdrop 1 SOL (devnet)</button>
+    <button id="btnInit"    disabled>Выполнить init()</button>
+    <button id="btn-delete-init"  disabled>🗑️ Удалить PDA (delete_init)</button>
+</div>
+
+<div class="muted">
+    В Phantom выбери сеть <b>Devnet</b>. Логи ниже и в консоли (F12 → Console).
+</div>
+
+<pre id="log"></pre>
+
+<!-- Единственная зависимость: web3.js -->
+<script src="https://unpkg.com/@solana/web3.js@1.95.0/lib/index.iife.min.js"></script>
+<script>
+    (async () => {
+    const logEl = document.getElementById("log");
+    const autoScroll = () => { logEl.scrollTop = logEl.scrollHeight; };
+    const log = (...a) => { console.log(...a); logEl.textContent += a.join(" ") + "\n"; autoScroll(); };
+    const logOk  = (...a) => log('%c' + a.join(" "), 'color:#86efac');
+    const logErr = (...a) => log('%c' + a.join(" "), 'color:#fca5a5');
+
+    // ===== ПАРАМЕТРЫ ПРОЕКТА =====
+    const RPC_URL    = "https://api.devnet.solana.com";
+    const PROGRAM_ID = new solanaWeb3.PublicKey("92sgkgx7KHpbhQu81mNGHaKa7skJB7esArVdPM7paDSW");
+    const STATE_SEED = "shine_investments_state";
+
+    // Лучше "processed" для симуляций + "confirmed" для подтверждений
+    const connection = new solanaWeb3.Connection(RPC_URL, { commitment: "confirmed" });
+    const enc = new TextEncoder();
+
+    let provider = null;       // Phantom provider (window.solana)
+    let walletPubkey = null;   // PublicKey пользователя из Phantom
+    let logsSubId = null;      // id подписки на логи программы
+
+    // ===== УТИЛИТЫ ОШИБОК/ЛОГОВ =====
+    function safeJson(v) {
+    try { return JSON.stringify(v, null, 2); } catch { return String(v); }
+}
+
+    function printRpcError(prefix, e) {
+    // Структура ошибок Solana/Anchor часто лежит в e, e.message, e.data, e.logs, e.code
+    logErr(prefix);
+    if (!e) return;
+
+    if (e.message) logErr("message:", e.message);
+    if (e.code !== undefined) logErr("code:", e.code);
+    if (e.name) logErr("name:", e.name);
+
+    // web3.js/JSON-RPC иногда кладёт это сюда:
+    if (e.data) {
+    if (e.data.logs) {
+    logErr("logs:");
+    (e.data.logs || []).forEach(l => logErr("  " + l));
+}
+    if (e.data.err) {
+    logErr("rpc err:", safeJson(e.data.err));
+}
+}
+
+    // Некоторые кошельки/обёртки кладут логи прямо в e.logs
+    if (e.logs) {
+    logErr("logs:");
+    (e.logs || []).forEach(l => logErr("  " + l));
+}
+
+    // Стек — в конце
+    if (e.stack) {
+    logErr("stack:\n" + e.stack);
+}
+}
+
+    async function simulateAndLog(tx) {
+    // Симуляция перед отправкой — ключ к пониманию, где падает инструкция.
+    try {
+    const sim = await connection.simulateTransaction(tx, {
+    sigVerify: false,           // подпись не требуется
+    commitment: "processed"
+});
+    const v = sim.value;
+    log("🔎 simulate result — err:", safeJson(v.err));
+    if (v.logs?.length) {
+    log("🪵 simulate logs:");
+    v.logs.forEach(l => log("  " + l));
+}
+    if (v.unitsConsumed !== undefined) {
+    log("⛽ compute units (simulate):", v.unitsConsumed);
+}
+    return v;
+} catch (e) {
+    printRpcError("❌ Ошибка simulateTransaction:", e);
+    return null;
+}
+}
+
+    async function confirmAndLog(signature, blockhashCtx) {
+    try {
+    const { blockhash, lastValidBlockHeight } = blockhashCtx;
+    log("🧱 confirm with blockhash/lastValid:", blockhash, "/", lastValidBlockHeight);
+    const res = await connection.confirmTransaction(
+{ signature, blockhash, lastValidBlockHeight },
+    "confirmed"
+    );
+    log("📬 confirmation status:", safeJson(res.value));
+    return res.value;
+} catch (e) {
+    printRpcError("❌ Ошибка confirmTransaction:", e);
+    return null;
+}
+}
+
+    async function getSigStatus(signature) {
+    try {
+    const st = await connection.getSignatureStatus(signature, { searchTransactionHistory: true });
+    log("🧾 signature status:", safeJson(st?.value));
+    return st?.value;
+} catch (e) {
+    printRpcError("❌ Ошибка getSignatureStatus:", e);
+}
+}
+
+    // ===== Anchor discriminator (8 байт) =====
+    async function anchorDiscriminator8(name) {
+    const hash = await crypto.subtle.digest("SHA-256", enc.encode("global:" + name));
+    return new Uint8Array(hash).slice(0, 8);
+}
+
+    // ===== PDA =====
+    async function getStatePda() {
+    const [pda] = await solanaWeb3.PublicKey.findProgramAddress(
+    [enc.encode(STATE_SEED)],
+    PROGRAM_ID
+    );
+    return pda;
+}
+
+    // ===== Отправка через Phantom с расширенным логированием =====
+    async function sendViaPhantom(tx, blockhashCtx) {
+        // Вариант с signAndSendTransaction вернёт сразу signature,
+        // но иногда теряются preflight-детали. Мы дополнительно логируем simulate.
+        // Обязательно: транзакция без подписей, место под Lighthouse-инструкции.
+        await simulateAndLog(tx); // можно оставить, подпись не требуется
+        if (!provider.signAndSendTransaction) throw new Error("Phantom не поддерживает signAndSendTransaction");
+        const {signature} = await provider.signAndSendTransaction(tx);
+        logOk("✍️ отправлено, сигнатура:", signature);
+        await confirmAndLog(signature, blockhashCtx);
+        await getSigStatus(signature);
+        return signature;
+
+    }
+
+    function setButtonsEnabled(connected) {
+    document.getElementById("btnInfo").disabled    = !connected;
+    document.getElementById("btnAirdrop").disabled = !connected;
+    document.getElementById("btnInit").disabled    = !connected;
+    document.getElementById("btn-delete-init").disabled = !connected;
+}
+
+    // ===== CONNECT =====
+    document.getElementById("btnConnect").addEventListener("click", async () => {
+    try {
+    if (!window.solana || !window.solana.isPhantom) {
+    logErr("❌ Phantom не найден. Установи расширение Phantom Wallet.");
+    return;
+}
+    provider = window.solana;
+
+    // Подключаемся ТОЛЬКО по клику пользователя:
+    log("🔌 Ожидаем подключение Phantom…");
+    await provider.connect(); // без onlyIfTrusted — это уже явный жест пользователя
+
+    walletPubkey = provider.publicKey;
+    logOk("✅ Подключено:", walletPubkey.toBase58());
+    setButtonsEnabled(true);
+
+    // Подписка на логи программы — помогает увидеть то, что в simulate/confirm могло не попасть
+    try {
+    if (logsSubId) {
+    await connection.removeOnLogsListener(logsSubId);
+    logsSubId = null;
+}
+    logsSubId = connection.onLogs(PROGRAM_ID, (ev) => {
+    log("🛰 onLogs:", ev.signature, "err:", safeJson(ev.err));
+    (ev.logs || []).forEach(l => log("  " + l));
+}, "confirmed");
+    log("📡 Подписка на логи программы включена.");
+} catch (e) {
+    printRpcError("⚠️ Не удалось подписаться на логи программы:", e);
+}
+
+    provider.on?.("disconnect", async () => {
+    log("🔌 Отключено");
+    setButtonsEnabled(false);
+    walletPubkey = null;
+    if (logsSubId) {
+    try { await connection.removeOnLogsListener(logsSubId); } catch {}
+    logsSubId = null;
+}
+});
+} catch (e) {
+    printRpcError("❌ Connect error:", e);
+}
+});
+
+    // ===== INFO =====
+    document.getElementById("btnInfo").addEventListener("click", async () => {
+    try {
+    if (!walletPubkey) throw new Error("Сначала подключи Phantom.");
+    const balanceLamports = await connection.getBalance(walletPubkey, "processed");
+    const statePda = await getStatePda();
+    log("👛 Кошелёк:", walletPubkey.toBase58());
+    log("💰 Баланс:", balanceLamports / solanaWeb3.LAMPORTS_PER_SOL, "SOL");
+    log("📦 statePda:", statePda.toBase58());
+    log("🌐 RPC:", RPC_URL);
+} catch (e) {
+    printRpcError("❌ Ошибка INFO:", e);
+}
+});
+
+    // ===== AIRDROP (devnet) =====
+    document.getElementById("btnAirdrop").addEventListener("click", async () => {
+    try {
+    if (!walletPubkey) throw new Error("Сначала подключи Phantom.");
+    log("⛽ Запрос airdrop 1 SOL на", walletPubkey.toBase58());
+    const sig = await connection.requestAirdrop(walletPubkey, 1 * solanaWeb3.LAMPORTS_PER_SOL);
+    log("⏳ confirm airdrop…");
+    const { value: ctx } = await connection.getLatestBlockhashAndContext("processed");
+    await confirmAndLog(sig, ctx);
+    logOk("✅ Airdrop tx:", sig);
+    const bal = await connection.getBalance(walletPubkey);
+    log("💰 Новый баланс:", bal / solanaWeb3.LAMPORTS_PER_SOL, "SOL");
+} catch (e) {
+    printRpcError("❌ Ошибка airdrop:", e);
+}
+});
+
+    // ===== INIT() =====
+    document.getElementById("btnInit").addEventListener("click", async () => {
+    try {
+    if (!walletPubkey) throw new Error("Сначала подключи Phantom.");
+
+    const statePda = await getStatePda();
+    log("🚀 Вызываем init()");
+    log("   payer:    ", walletPubkey.toBase58());
+    log("   statePda: ", statePda.toBase58());
+    log("   programId:", PROGRAM_ID.toBase58());
+
+    // 8 байт дискриминатора Anchor для "global:init"
+    const data = await anchorDiscriminator8("init"); // Uint8Array длиной 8
+
+    // Аккаунты в том порядке, который ожидает on-chain метод
+    const keys = [
+{ pubkey: walletPubkey,                     isSigner: true,  isWritable: true  }, // payer (signer)
+{ pubkey: statePda,                         isSigner: false, isWritable: true  }, // state PDA
+{ pubkey: solanaWeb3.SystemProgram.programId, isSigner: false, isWritable: false },
+    ];
+
+    const ix = new solanaWeb3.TransactionInstruction({ programId: PROGRAM_ID, keys, data });
+
+    // Получаем блокхеш/lastValidBlockHeight и логируем
+    const { value: ctx } = await connection.getLatestBlockhashAndContext("processed");
+    const { blockhash, lastValidBlockHeight } = ctx;
+    log("⏱ blockhash:", blockhash);
+    log("⏱ lastValidBlockHeight:", lastValidBlockHeight);
+
+    const tx = new solanaWeb3.Transaction({
+    feePayer: walletPubkey,
+    recentBlockhash: blockhash,
+}).add(ix);
+
+    // 1) Симуляция — сразу покажет логи Anchor/InstructionError
+    await simulateAndLog(tx);
+
+    log("📝 Подписываем в Phantom…");
+    // 2) Отправка + подтверждение с расширенными логами
+    const sig = await sendViaPhantom(tx, { blockhash, lastValidBlockHeight });
+    logOk("✅ Готово! tx:", sig);
+    log("🔗 Explorer:", `https://explorer.solana.com/tx/${sig}?cluster=devnet`);
+} catch (e) {
+    // Печатаем максимально подробно
+    printRpcError("❌ Ошибка init:", e);
+}
+});
+
+// ===== DELETE INIT =====
+document.getElementById("btn-delete-init").addEventListener("click", async () => {
+    try {
+        // 1) Проверка подключения
+        if (!walletPubkey) throw new Error("Сначала подключи Phantom.");
+
+        // 2) PDA — те же сиды, что и в init
+        const statePda = await getStatePda();
+        log("🗑️ Вызываем delete_init()");
+        log("   signer:   ", walletPubkey.toBase58());
+        log("   statePda: ", statePda.toBase58());
+        log("   programId:", PROGRAM_ID.toBase58());
+
+        // 3) Дискриминатор Anchor для "global:delete_init"
+        const data = await anchorDiscriminator8("delete_init"); // 8 байт
+
+        // 4) Аккаунты в порядке, который ожидает on-chain метод
+        const keys = [
+            { pubkey: walletPubkey,                         isSigner: true,  isWritable: true  }, // signer (получатель ренты)
+            { pubkey: statePda,                             isSigner: false, isWritable: true  }, // state_pda
+            { pubkey: solanaWeb3.SystemProgram.programId,   isSigner: false, isWritable: false },
+        ];
+
+        const ix = new solanaWeb3.TransactionInstruction({
+            programId: PROGRAM_ID,
+            keys,
+            data, // только 8 байт дискриминатора, т.к. у метода нет аргументов
+        });
+
+        // 5) Блокхеш, формирование транзакции
+        const { value: ctx } = await connection.getLatestBlockhashAndContext("processed");
+        const { blockhash, lastValidBlockHeight } = ctx;
+        log("⏱ blockhash:", blockhash);
+        log("⏱ lastValidBlockHeight:", lastValidBlockHeight);
+
+        const tx = new solanaWeb3.Transaction({
+            feePayer: walletPubkey,
+            recentBlockhash: blockhash,
+        }).add(ix);
+
+        // 6) Симуляция → отправка → подтверждение
+        await simulateAndLog(tx);
+
+        log("📝 Подписываем в Phantom…");
+        const sig = await sendViaPhantom(tx, { blockhash, lastValidBlockHeight });
+
+        logOk("✅ delete_init выполнен. tx:", sig);
+        log("🔗 Explorer:", `https://explorer.solana.com/tx/${sig}?cluster=devnet`);
+        alert(`PDA удалён, рента возвращена подписанту.\nTx: ${sig}`);
+    } catch (e) {
+        printRpcError("❌ Ошибка delete_init:", e);
+        alert(`Ошибка delete_init: ${e.message || e}`);
+    }
+});
+
+    // Больше НИКАКИХ автоконнектов на загрузке страницы.
+        if (window.solana?.isPhantom) {
+            provider = window.solana;
+            log("ℹ️ Phantom найден. Нажми «Connect Phantom», чтобы подключиться.");
+        } else {
+            log("ℹ️ Установи Phantom Wallet: https://phantom.app");
+        }
+    }
+
+
+)();
+
+</script>
+</body>
+</html>

shine/programs/shine_payments/src/investments.rs

@@ -0,0 +1,326 @@
+use anchor_lang::prelude::*;
+
+use anchor_lang::solana_program::{program::invoke_signed, system_instruction};
+use common::utils::*; // тянем общие PDA-хелперы из programs/common
+
+// === добавлено: используем наш NFT-модуль ===
+use crate::nft::{CreateNftParams, create_nft_with_freeze};
+// ============================================
+
+/// Утилита чтения структуры из PDA: читает байты и десериализует.
+/// Возвращает ошибку, если данных нет/пустые/неверный формат.
+fn read_state_from_pda(pda: &AccountInfo) -> Result<InvestState> {
+    let raw = safe_read_pda(pda);                         // ← берём Vec<u8> (или пустой)
+    require!(!raw.is_empty(), ErrCode::EmptyPdaData);     // ← пусто — ошибка
+    let st = deserialize_invest_state(&raw)?;             // ← десериализуем по формату
+    require!(st.format == INVEST_STATE_FORMAT_V1, ErrCode::UnsupportedFormat); // ← проверяем версию
+    Ok(st)
+}
+
+/// Утилита записи структуры в PDA: сериализует и пишет.
+/// Важно: сам аккаунт уже должен существовать и быть #[account(mut)].
+fn write_state_to_pda(pda: &AccountInfo, s: &InvestState) -> Result<()> {
+    let raw = serialize_invest_state_v1(s); // ← 24 байта
+    write_to_pda(pda, &raw)                 // ← записываем в начало data
+}
+
+/// ==============================================
+/// Контексты инструкций (минимально необходимые)
+/// ==============================================
+
+/// init: создаём PDA и кладём в него PayStateV1 {format=1, coef=10, ...0}
+#[derive(Accounts)]
+pub struct Init<'info> {
+    /// Плательщик аренды за PDA; подписант транзакции.
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    /// Наш PDA (с произвольным типом, чтобы работать через AccountInfo).
+    /// Проверку адреса делаем в handler (по seed + bump), чтобы избежать подмены.
+    /// CHECK: проверяется вручную по адресу
+    #[account(mut)]
+    pub state_pda: UncheckedAccount<'info>,
+
+    /// Системная программа.
+    pub system_program: Program<'info, System>,
+}
+
+/// Общие аккаунты для invest/add_bonus/claim:
+/// Везде просто читаем/пишем одно и то же состояние из того же PDA.
+#[derive(Accounts)]
+pub struct UseState<'info> {
+    /// Любой платящий/подписант (в реальном коде — свои проверки).
+    pub signer: Signer<'info>,
+
+    /// Тот же PDA с состоянием (должен уже существовать).
+    /// CHECK: проверяется вручную по адресу
+    #[account(mut)]
+    pub state_pda: UncheckedAccount<'info>,
+
+    /// Системная программа (на всякий случай; может не понадобиться).
+    pub system_program: Program<'info, System>,
+}
+
+/// ==============================================
+/// Программа
+/// ==============================================
+
+use super::*;
+use anchor_lang::prelude::*;
+
+
+/// ------------------------------------------
+/// init: создаёт PDA и записывает в него дефолтное состояние.
+/// format = 1, coef = 10, остальные поля = 0.
+/// ------------------------------------------
+pub fn init(ctx: Context<Init>) -> Result<()> {
+    let program_id = ctx.program_id; // ← адрес этой программы
+
+    // 1. Проверка что вызывает именно разрешённый ключ
+    /* todo   пока все могут вызыватьно                                         !! но в итоге будет добавленна проверка что бы только дао могло вызвать эту функцию один раз
+    require_keys_eq!(
+        ctx.accounts.payer.key(),
+        ALLOWED_INIT_CALLER,
+        ErrCode::InvalidSigner
+    );
+*/
+
+    // 2. Проверка что PDA ещё не создан
+    if ctx.accounts.state_pda.data_len() > 0 && ctx.accounts.state_pda.owner != &System::id() {
+        return Err(error!(ErrCode::PdaAlreadyExists));
+    }
+    
+    // 2. Ещё раз Проверка что PDA ещё не создан  
+    if ctx.accounts.state_pda.owner != &System::id()
+        || ctx.accounts.state_pda.lamports() > 0
+    {
+        // Если аккаунт уже создан и не пустой
+        return Err(error!(ErrCode::PdaAlreadyExists));
+    }
+    
+    let pda_key_expected = Pubkey::find_program_address(&[crate::PDA_SEED_PREFIX], program_id).0; // ← вычисляем PDA
+    require_keys_eq!(
+        pda_key_expected,
+        ctx.accounts.state_pda.key(),
+        ErrCode::InvalidPdaAddress
+    ); // ← убеждаемся, что нам подали именно правильный PDA
+
+    // Конструируем дефолтную структуру состояния.
+    let state = InvestState {
+        format: INVEST_STATE_FORMAT_V1,  // ← 1
+        coef: crate::DEFAULT_COEF,       // ← 10
+        q1_tokens: 0,                    // ← нули
+        sum1_bonus: 0,
+        q1_paid_tokens: 0,
+        sum1_paid_bonus: 0,
+    };
+
+    // Сериализуем в 24 байта.
+    let data = serialize_invest_state_v1(&state);
+
+    // Для подписи PDA нужен bump; здесь получим (ключ, bump).
+    let (_pda_key, bump) = Pubkey::find_program_address(&[crate::PDA_SEED_PREFIX], program_id);
+
+    // Сиды для invoke_signed: [seed, bump]
+    let seeds: [&[u8]; 2] = [crate::PDA_SEED_PREFIX, &[bump]];
+
+    // Создаём и сразу записываем, арендный минимум оплачивает payer.
+    create_and_write_pda(
+        &ctx.accounts.state_pda.to_account_info(),   // куда пишем
+        &ctx.accounts.payer.to_account_info(),       // кто платит
+        &ctx.accounts.system_program.to_account_info(),
+        program_id,
+        &seeds,
+        data,
+        crate::PAY_STATE_SPACE,                      // резерв с запасом
+    )?;
+
+    Ok(())
+}
+
+/// ------------------------------------------
+/// invest: «внос инвестиций».
+/// По заданию: в начале читаем состояние, в конце сохраняем.
+/// (Здесь логика модификации не задана — оставляем как заглушку.)
+/// ------------------------------------------
+pub fn invest(ctx: Context<UseState>, _amount: u64) -> Result<()> {
+    // 1) читаем
+    let mut st = read_state_from_pda(&ctx.accounts.state_pda.to_account_info())?; // ← PayStateV1
+
+    // --- тут можно модифицировать st по твоей бизнес-логике ---
+    // Например, ничего не меняем сейчас (заглушка).
+    let _ = &mut st; // чтоб компилятор не ругался, если пока не используем
+
+    // 2) сохраняем
+    write_state_to_pda(&ctx.accounts.state_pda.to_account_info(), &st)?;
+    Ok(())
+}
+
+/// ------------------------------------------
+/// add_bonus: «начисление бонусов» (обычно вызывать от DAO).
+/// По заданию: читаем в начале, создаём/добавляем NFT в очередь, сохраняем в конце.
+/// Для операций с NFT используем расширенный контекст AddBonusCtx (см. lib.rs).
+/// ------------------------------------------
+pub fn add_bonus(ctx: Context<crate::AddBonusCtx>, investor: Pubkey, amount: u64) -> Result<()> {
+    // 1) читаем состояние
+    let mut st = read_state_from_pda(&ctx.accounts.state_pda.to_account_info())?;
+
+    // 2) создаём/добавляем NFT через модуль nft (создание metadata, mint 1, freeze, master edition, verify)
+    let next_index = st.q1_tokens as u64 + 1;
+    let params = CreateNftParams {
+        name: format!("Bonus #{}", next_index),
+        symbol: "BN".to_string(),
+        uri: "https://example.com/nft.json".to_string(), // заглушка для devnet-теста
+        index: next_index,
+        recipient: investor,
+    };
+
+    // ВАЖНО: mint_pda должен быть создан ТЕСТОМ заранее с decimals=0, mint_authority=signer, freeze_authority=signer.
+    create_nft_with_freeze(&ctx, params)?;
+
+    // 3) обновляем агрегаты очереди (минимально: увеличим счётчик и сумму бонусов)
+    st.q1_tokens = st.q1_tokens.saturating_add(1);
+    let add = u32::try_from(core::cmp::min(amount, u64::from(u32::MAX))).unwrap_or(u32::MAX);
+    st.sum1_bonus = st.sum1_bonus.saturating_add(add);
+
+    // 4) сохраняем
+    write_state_to_pda(&ctx.accounts.state_pda.to_account_info(), &st)?;
+    Ok(())
+}
+
+/// ------------------------------------------
+/// claim: «выплата».
+/// По заданию: читаем в начале, сохраняем в конце.
+/// ------------------------------------------
+pub fn claim(ctx: Context<UseState>) -> Result<()> {
+    // 1) читаем
+    let mut st = read_state_from_pda(&ctx.accounts.state_pda.to_account_info())?;
+
+    // --- тут твоя логика списаний/выплат ---
+    let _ = &mut st; // заглушка
+
+    // 2) сохраняем
+    write_state_to_pda(&ctx.accounts.state_pda.to_account_info(), &st)?;
+    Ok(())
+}
+
+
+
+
+
+//todo
+
+
+
+
+
+/// ==============================================
+/// Коды ошибок (берём из твоего блока; можно расширять)
+/// ==============================================
+
+#[error_code]
+pub enum ErrCode {
+    /// Система уже инициализирована и не может быть инициализирована повторно!
+    #[msg("Система уже инициализирована и не может быть инициализирована повторно!")]
+    SystemAlreadyInitialized = 1000,
+
+    #[msg("PDA не содержит данных или не инициализирован")]
+    EmptyPdaData = 1002,
+
+    #[msg("Пользователь уже зарегистрирован")]
+    UserAlreadyExists = 1003,
+
+    #[msg("Некорректный логин")]
+    InvalidLogin = 1004,
+
+    #[msg("Не совпадает PDA адрес")]
+    InvalidPdaAddress = 1006,
+
+    #[msg("Формат данных не поддерживается")]
+    UnsupportedFormat = 1011,
+
+    #[msg("Ошибка при десериализации")]
+    DeserializationError = 1012,
+
+    /// PDA уже существует, создание невозможно
+    #[msg("PDA-аккаунт уже существует и не может быть создан повторно.")]
+    PdaAlreadyExists = 1009,
+
+    #[msg("Подписавший не совпадает с ожидаемым пользователем (временное ограничение)")]
+    InvalidSigner = 1005,
+
+    /// Не получилось создать пользователя
+    #[msg("Не получилось создать пользователя, система уже перегружена, попробуйте позже!")]
+    NoSuitableIdPda = 1010,
+}
+
+
+
+
+
+use anchor_lang::prelude::*;
+
+/// ================================
+/// КОНСТАНТЫ ФОРМАТА / ДЛИНЫ ДАННЫХ
+/// ================================
+
+/// Версия формата хранения состояния.
+/// Мы жёстко фиксируем «1», чтобы код мог отличать будущие версии.
+pub const INVEST_STATE_FORMAT_V1: u32 = 1;
+
+/// Сырые данные состояния V1 занимают ровно 6 * 4 = 24 байта.
+pub const INVEST_STATE_RAW_LEN_V1: usize = 24; // байт
+
+/// ================================
+/// ОПИСАНИЕ СТРУКТУРЫ СОСТОЯНИЯ (V1)
+/// ================================
+#[derive(Clone, Copy, Debug, Default)]
+pub struct InvestState {
+    pub format: u32,
+    pub coef: u32,
+    pub q1_tokens: u32,
+    pub sum1_bonus: u32,
+    pub q1_paid_tokens: u32,
+    pub sum1_paid_bonus: u32,
+}
+
+/// ========================================
+/// СЕРИАЛИЗАЦИЯ (структура -> массив байт)
+/// ========================================
+pub fn serialize_invest_state_v1(s: &InvestState) -> Vec<u8> {
+    let mut out = Vec::with_capacity(INVEST_STATE_RAW_LEN_V1);
+    out.extend_from_slice(&INVEST_STATE_FORMAT_V1.to_le_bytes()); // [0..4)
+    out.extend_from_slice(&s.coef.to_le_bytes());            // [4..8)
+    out.extend_from_slice(&s.q1_tokens.to_le_bytes());       // [8..12)
+    out.extend_from_slice(&s.sum1_bonus.to_le_bytes());      // [12..16)
+    out.extend_from_slice(&s.q1_paid_tokens.to_le_bytes());  // [16..20)
+    out.extend_from_slice(&s.sum1_paid_bonus.to_le_bytes()); // [20..24)
+    debug_assert_eq!(out.len(), INVEST_STATE_RAW_LEN_V1);
+    out
+}
+
+/// ===========================================
+/// ДЕСЕРИАЛИЗАЦИЯ (массив байт -> структура)
+/// ===========================================
+pub fn deserialize_invest_state(data: &[u8]) -> Result<InvestState> {
+    if data.len() < INVEST_STATE_RAW_LEN_V1 {
+        return Err(error!(ErrCode::DeserializationError));
+    }
+    fn read_u32_le(slice: &[u8], start: usize) -> u32 {
+        let bytes: [u8; 4] = slice[start..start + 4]
+            .try_into()
+            .expect("slice has enough length due to pre-check");
+        u32::from_le_bytes(bytes)
+    }
+    let format = read_u32_le(data, 0);
+    if format != INVEST_STATE_FORMAT_V1 {
+        return Err(error!(ErrCode::UnsupportedFormat));
+    }
+    let coef            = read_u32_le(data, 4);
+    let q1_tokens       = read_u32_le(data, 8);
+    let sum1_bonus      = read_u32_le(data, 12);
+    let q1_paid_tokens  = read_u32_le(data, 16);
+    let sum1_paid_bonus = read_u32_le(data, 20);
+
+    Ok(InvestState { format, coef, q1_tokens, sum1_bonus, q1_paid_tokens, sum1_paid_bonus })
+}

shine/programs/shine_payments/src/lib.rs

@@ -0,0 +1,158 @@
+use anchor_lang::prelude::*;
+
+declare_id!("6Hes38UKFGF8cfQDQDVWoMGcSzGMUAgamWG31hCVhyPY");
+
+
+/// Подключаем модуль с полной реализацией.
+pub mod investments;
+use investments::*; // импортируем всё в корень
+
+// === модуль NFT ===
+pub mod nft;
+
+// ==============================================
+// Константы формата / сидов / размеров
+// ==============================================
+
+/// Префикс (seed) для PDA, где храним глобальное состояние выплат.
+/// Важно: сид — это просто набор байт; здесь он фиксированный.
+pub const PDA_SEED_PREFIX: &[u8] = b"shine_investments_state";
+
+/// Значение коэффициента «по умолчанию» при инициализации.
+pub const DEFAULT_COEF: u32 = 10; // ← «коэффициент» = 10 при init
+
+/// Ровно столько байт резервируем под PDA-данные.
+/// (Можно добавить запас на будущее, но по заданию — только 28.)
+pub const PAY_STATE_SPACE: u64 = 50; // просто сделал с запасом
+
+// ==============================================
+// Программа
+// ==============================================
+
+#[program]
+pub mod shine_payments {
+    use super::*;
+    // Явно подтягиваем типы и функции, чтобы не было путаницы после предыдущих ошибок парсера
+    use crate::investments::{Init, UseState};
+    use crate::investments::{
+        add_bonus as inv_add_bonus, claim as inv_claim, init as inv_init, invest as inv_invest,
+        ErrCode,
+    };
+
+    /// init — создаёт PDA и кладёт дефолтное состояние.
+    pub fn init(ctx: Context<Init>) -> Result<()> {
+        inv_init(ctx)
+    }
+
+    /// invest — в начале читает состояние, в конце сохраняет (логика внутри модуля).
+    pub fn invest(ctx: Context<UseState>, amount: u64) -> Result<()> {
+        inv_invest(ctx, amount)
+    }
+
+    /// add_bonus — начисление бонусов (обычно от DAO).
+    /// Для NFT используем расширенный контекст AddBonusCtx (с аккаунтами коллекции и т.п.).
+    pub fn add_bonus(ctx: Context<AddBonusCtx>, investor: Pubkey, amount: u64) -> Result<()> {
+        inv_add_bonus(ctx, investor, amount)
+    }
+
+    /// claim — выплата.
+    pub fn claim(ctx: Context<UseState>) -> Result<()> {
+        inv_claim(ctx)
+    }
+
+    /// ВРЕМЕННАЯ ФУНКЦИЯ только для тестов (в итоговой версии её не будет):
+    /// deleteInit — удалить PDA из init и вернуть ренту подписанту.
+    pub fn delete_init(ctx: Context<DeleteInit>) -> Result<()> {
+        let program_id = ctx.program_id;
+
+        // PDA по тем же сид/бамп, что и в init
+        let (expected_pda, _bump) = Pubkey::find_program_address(&[PDA_SEED_PREFIX], program_id);
+        require_keys_eq!(
+            expected_pda,
+            ctx.accounts.state_pda.key(),
+            ErrCode::InvalidPdaAddress
+        );
+
+        // Рента уйдёт на счёт подписанта (signer)
+        common::utils::delete_pda_return_rent(
+            &ctx.accounts.state_pda.to_account_info(),
+            &ctx.accounts.signer.to_account_info(),
+            program_id,
+        )
+    }
+}
+
+// ==============================================
+// Контексты вне #[program]
+// ==============================================
+
+/// Контекст для deleteInit (временный для тестов)
+#[derive(Accounts)]
+pub struct DeleteInit<'info> {
+    /// Подписант транзакции — ПОЛУЧАТЕЛЬ ренты
+    #[account(mut)]
+    pub signer: Signer<'info>,
+
+    /// Тот самый PDA из init
+    /// CHECK: адрес валидируем в хендлере по сид-у
+    #[account(mut)]
+    pub state_pda: UncheckedAccount<'info>,
+
+    /// Системная программа
+    pub system_program: Program<'info, System>,
+}
+
+/// Контекст для add_bonus: полный набор аккаунтов для операций с NFT и коллекцией.
+/// (Комменты по стилю проекта оставлены.)
+#[derive(Accounts)]
+pub struct AddBonusCtx<'info> {
+    /// Любой платящий/подписант (в реальном коде — свои проверки).
+    #[account(mut)]
+    pub signer: Signer<'info>,
+
+    /// Тот же PDA с состоянием (должен уже существовать).
+    /// CHECK: проверяется вручную по адресу
+    #[account(mut)]
+    pub state_pda: UncheckedAccount<'info>,
+
+    // --- аккаунты минтимого NFT ---
+    /// Mint создаваемого NFT (должен быть создан заранее: decimals=0, mint_authority=signer, freeze_authority=signer)
+    /// CHECK
+    #[account(mut)]
+    pub mint_pda: UncheckedAccount<'info>,
+
+    /// ATA получателя (может быть предсоздан тестом)
+    /// CHECK
+    #[account(mut)]
+    pub recipient_ata: UncheckedAccount<'info>,
+    /// Владелец ATA (инвестор)
+    /// CHECK
+    pub recipient_owner: UncheckedAccount<'info>,
+
+    // --- аккаунты коллекции (уже созданной заранее) ---
+    /// CHECK
+    pub collection_mint: UncheckedAccount<'info>,
+    /// CHECK
+    #[account(mut)]
+    pub collection_metadata_pda: UncheckedAccount<'info>,
+    /// CHECK
+    #[account(mut)]
+    pub collection_master_edition_pda: UncheckedAccount<'info>,
+    /// Апдейтер коллекции (update authority)
+    pub collection_update_authority: Signer<'info>,
+
+    // --- metadata + master edition для создаваемого NFT ---
+    /// CHECK
+    #[account(mut)]
+    pub metadata_pda: UncheckedAccount<'info>,
+    /// CHECK
+    #[account(mut)]
+    pub master_edition_pda: UncheckedAccount<'info>,
+
+    // --- программы ---
+    /// CHECK: проверяется по ID внутри nft.rs
+    pub token_metadata_program: UncheckedAccount<'info>,
+    pub token_program: Program<'info, anchor_spl::token::Token>,
+    pub associated_token_program: Program<'info, anchor_spl::associated_token::AssociatedToken>,
+    pub system_program: Program<'info, System>,
+}

shine/programs/shine_payments/src/nft.rs

@@ -0,0 +1,190 @@
+use anchor_lang::prelude::*;
+use anchor_lang::solana_program::{program::invoke, program::invoke_signed};
+use anchor_spl::{associated_token::AssociatedToken, token::Token};
+
+use mpl_token_metadata::{
+    ID as TM_ID,
+    instructions::{
+        CreateMasterEditionV3Builder,
+        CreateMetadataAccountV3Builder,
+        SetAndVerifySizedCollectionItemBuilder,
+    },
+    types::{Collection, Creator, DataV2, Uses, UseMethod},
+};
+
+use spl_token::instruction as spl_ix;
+
+/// Параметры для минта NFT
+#[derive(Clone)]
+pub struct CreateNftParams {
+    pub name: String,
+    pub symbol: String,
+    pub uri: String,
+    pub index: u64,
+    pub recipient: Pubkey,
+}
+
+/// Создание metadata, чеканка 1 токена, freeze ATA, создание master edition, verify в коллекции.
+pub fn create_nft_with_freeze(
+    ctx: &Context<crate::AddBonusCtx>,
+    params: CreateNftParams,
+) -> Result<()> {
+    let a = &ctx.accounts;
+
+    // Проверяем что это именно программа Metaplex Token Metadata
+    require_keys_eq!(a.token_metadata_program.key(), TM_ID, CustomError::InvalidMetadataProgram);
+
+    // 1) Создание Metadata для нового NFT
+    let creators = Some(vec![Creator {
+        address: a.collection_update_authority.key(),
+        verified: true,
+        share: 100,
+    }]);
+
+    let data = DataV2 {
+        name: truncate(&params.name, 32),
+        symbol: truncate(&params.symbol, 10),
+        uri: truncate(&params.uri, 256),
+        seller_fee_basis_points: 0,
+        creators,
+        collection: Some(Collection {
+            verified: false, // отметим как часть коллекции позже через verify
+            key: a.collection_mint.key(),
+        }),
+        uses: Some(Uses {
+            use_method: UseMethod::Burn,
+            remaining: 1,
+            total: 1,
+        }),
+    };
+
+    // В mpl-token-metadata v5 update_authority(pubkey, is_signer: bool)
+    let ix_md = CreateMetadataAccountV3Builder::new()
+        .metadata(a.metadata_pda.key())
+        .mint(a.mint_pda.key())
+        .mint_authority(a.signer.key())
+        .payer(a.signer.key())
+        .update_authority(a.collection_update_authority.key(), true)
+        .system_program(a.system_program.key())
+        .data(data)
+        .is_mutable(true)
+        .instruction();
+
+    invoke_signed(
+        &ix_md,
+        &[
+            a.metadata_pda.to_account_info(),
+            a.mint_pda.to_account_info(),
+            a.signer.to_account_info(),
+            a.collection_update_authority.to_account_info(),
+            a.system_program.to_account_info(),
+            a.token_metadata_program.to_account_info(),
+        ],
+        &[],
+    )?;
+
+    // 2) Чеканим 1 токен на ATA получателя
+    let ix_mint_to = spl_ix::mint_to(
+        &a.token_program.key(),
+        &a.mint_pda.key(),
+        &a.recipient_ata.key(),
+        &a.signer.key(),
+        &[],
+        1,
+    )?;
+    invoke(
+        &ix_mint_to,
+        &[
+            a.mint_pda.to_account_info(),
+            a.recipient_ata.to_account_info(),
+            a.signer.to_account_info(),
+            a.token_program.to_account_info(),
+        ],
+    )?;
+
+    // 3) Замораживаем ATA получателя (freeze authority = signer)
+    let ix_freeze = spl_ix::freeze_account(
+        &a.token_program.key(),
+        &a.recipient_ata.key(),
+        &a.mint_pda.key(),
+        &a.signer.key(),
+        &[],
+    )?;
+    invoke(
+        &ix_freeze,
+        &[
+            a.recipient_ata.to_account_info(),
+            a.mint_pda.to_account_info(),
+            a.signer.to_account_info(),
+            a.token_program.to_account_info(),
+        ],
+    )?;
+
+    // 4) Создаём Master Edition
+    let ix_me = CreateMasterEditionV3Builder::new()
+        .edition(a.master_edition_pda.key())
+        .mint(a.mint_pda.key())
+        .update_authority(a.collection_update_authority.key())
+        .mint_authority(a.signer.key())
+        .payer(a.signer.key())
+        .metadata(a.metadata_pda.key())
+        .token_program(a.token_program.key())
+        .system_program(a.system_program.key())
+        .max_supply(0)
+        .instruction();
+
+    invoke_signed(
+        &ix_me,
+        &[
+            a.master_edition_pda.to_account_info(),
+            a.mint_pda.to_account_info(),
+            a.collection_update_authority.to_account_info(),
+            a.signer.to_account_info(),
+            a.metadata_pda.to_account_info(),
+            a.token_program.to_account_info(),
+            a.system_program.to_account_info(),
+            a.token_metadata_program.to_account_info(),
+        ],
+        &[],
+    )?;
+
+    // 5) Verify как часть коллекции
+    // Метод называется collection_master_edition_account(...)
+    let ix_verify = SetAndVerifySizedCollectionItemBuilder::new()
+        .metadata(a.metadata_pda.key())
+        .collection_authority(a.collection_update_authority.key())
+        .payer(a.signer.key())
+        .update_authority(a.collection_update_authority.key())
+        .collection_mint(a.collection_mint.key())
+        .collection(a.collection_metadata_pda.key())
+        .collection_master_edition_account(a.collection_master_edition_pda.key())
+        .instruction();
+
+    invoke_signed(
+        &ix_verify,
+        &[
+            a.metadata_pda.to_account_info(),
+            a.collection_update_authority.to_account_info(),
+            a.signer.to_account_info(),
+            a.collection_update_authority.to_account_info(),
+            a.collection_mint.to_account_info(),
+            a.collection_metadata_pda.to_account_info(),
+            a.collection_master_edition_pda.to_account_info(),
+            a.token_metadata_program.to_account_info(),
+        ],
+        &[],
+    )?;
+
+    msg!("NFT создан, заморожен, мастер-издание создано и верифицировано в коллекции (index={})", params.index);
+    Ok(())
+}
+
+fn truncate(s: &str, max: usize) -> String {
+    if s.len() <= max { s.to_string() } else { s.chars().take(max).collect() }
+}
+
+#[error_code]
+pub enum CustomError {
+    #[msg("Invalid Token Metadata program account")]
+    InvalidMetadataProgram,
+}

shine/programs/shine_users/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "shine_users"
+version = "0.1.0"
+description = "User registration smart contract"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "shine_users"
+test = false
+doctest = false
+bench = false
+
+[dependencies]
+anchor-lang = "0.31.1"
+common = { path = "../common" }
+ed25519-dalek = { version = "1.0.1", default-features = false, features = ["u64_backend"] }
+sha2 = "0.10"
+
+
+[features]
+default = []
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+anchor-debug = []
+custom-heap = []
+custom-panic = []
+cpi = []
+idl-build = ["anchor-lang/idl-build"]

shine/programs/shine_users/src/lib.rs

@@ -0,0 +1,23 @@
+use anchor_lang::prelude::*;
+
+pub mod users;
+pub mod settings;
+
+use users::*;
+
+
+declare_id!("5dFcWDNp42Xn9Vv4oDMJzM4obBJ8hvDuAtPX54fT5L3t");
+
+
+#[program]
+pub mod shine {
+    use super::*;
+
+    pub fn create_user_pda(ctx: Context<CreateUserPda>, args: CreateUserPdaArgs) -> Result<()> {
+        users::create_user_pda(ctx, args)
+    }
+
+    pub fn update_user_pda(ctx: Context<UpdateUserPda>, args: UpdateUserPdaArgs) -> Result<()> {
+        users::update_user_pda(ctx, args)
+    }
+}

shine/programs/shine_users/src/settings.rs

@@ -0,0 +1,12 @@
+pub const USER_PDA_SEED_PREFIX: &str = "login=";
+// Увеличили размер PDA, чтобы оставить запас под будущие расширения формата
+// (в частности, сценарии ротации root key с дополнительной подписью старого ключа).
+pub const USER_PDA_SPACE: usize = 768;
+
+pub const REGISTRATION_FEE_RECEIVER: &str = "6bFc5Gz5qF172GQhK5HpDbWs8F6qcSxdHn5XqAstf1fY";
+pub const REGISTRATION_FEE_LAMPORTS: u64 = 10_000_000; // 0.01 SOL
+
+pub const LIMIT_STEP: u64 = 10_000;
+pub const LAMPORTS_PER_LIMIT_STEP: u64 = 100_000; // 0.0001 SOL за 10_000 лимита
+
+pub const START_BONUS_LIMIT: u64 = 100_000;

shine/programs/shine_users/src/users.rs

@@ -0,0 +1,592 @@
+use crate::settings;
+use anchor_lang::prelude::*;
+use anchor_lang::solana_program::{program::invoke, system_instruction};
+use common::utils::{create_pda, safe_read_pda, write_to_pda, ErrCode};
+use ed25519_dalek::{PublicKey, Signature, Verifier};
+use sha2::{Digest, Sha256};
+use std::str::FromStr;
+
+const MAGIC: &[u8; 5] = b"SHiNE";
+const FORMAT_MAJOR: u8 = 1;
+const FORMAT_MINOR: u8 = 0;
+const RESERVED_BYTES: [u8; 5] = [0, 0, 0, 0, 0];
+const ZERO_HASH: [u8; 32] = [0; 32];
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
+pub struct UserMutableFields {
+    pub blockchain_key: Pubkey,
+    pub device_key: Pubkey,
+    pub chain_number: u16,
+    pub is_server: bool,
+    pub server_key: Pubkey,
+    pub server_address: String,
+    pub connection_servers: Vec<String>,
+    pub trusted_count: u8,
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
+pub struct CreateUserPdaArgs {
+    pub login: String,
+    pub root_key: Pubkey,
+    pub created_at_ms: u64,
+    pub additional_limit: u64,
+    pub fields: UserMutableFields,
+    pub signature: Vec<u8>,
+}
+
+#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
+pub struct UpdateUserPdaArgs {
+    pub login: String,
+    pub root_key: Pubkey,
+    pub created_at_ms: u64,
+    pub updated_at_ms: u64,
+    pub version: u32,
+    pub prev_hash: Vec<u8>,
+    pub additional_limit: u64,
+    pub fields: UserMutableFields,
+    pub signature: Vec<u8>,
+}
+
+pub struct UserRecord {
+    pub created_at_ms: u64,
+    pub updated_at_ms: u64,
+    pub version: u32,
+    pub prev_hash: [u8; 32],
+    pub login: String,
+    pub root_key: Pubkey,
+    pub blockchain_key: Pubkey,
+    pub device_key: Pubkey,
+    pub chain_number: u16,
+    pub balance: u64,
+    pub is_server: bool,
+    pub server_key: Pubkey,
+    pub server_address: String,
+    pub connection_servers: Vec<String>,
+    pub trusted_count: u8,
+    pub signature: [u8; 64],
+}
+
+#[derive(Accounts)]
+pub struct CreateUserPda<'info> {
+    /// CHECK: подписант транзакции, валидируется Anchor как signer и mut.
+    #[account(mut, signer)]
+    pub signer: AccountInfo<'info>,
+    /// CHECK: PDA пользователя, адрес проверяется вручную через seed в обработчике.
+    #[account(mut)]
+    pub user_pda: AccountInfo<'info>,
+    pub system_program: Program<'info, System>,
+    /// CHECK: адрес получателя комиссии проверяется вручную с константой settings.
+    #[account(mut)]
+    pub fee_receiver: AccountInfo<'info>,
+}
+
+#[derive(Accounts)]
+pub struct UpdateUserPda<'info> {
+    /// CHECK: подписант транзакции, валидируется Anchor как signer и mut.
+    #[account(mut, signer)]
+    pub signer: AccountInfo<'info>,
+    /// CHECK: PDA пользователя, адрес проверяется вручную через seed в обработчике.
+    #[account(mut)]
+    pub user_pda: AccountInfo<'info>,
+    pub system_program: Program<'info, System>,
+    /// CHECK: адрес получателя комиссии проверяется вручную с константой settings.
+    #[account(mut)]
+    pub fee_receiver: AccountInfo<'info>,
+}
+
+pub fn create_user_pda(ctx: Context<CreateUserPda>, args: CreateUserPdaArgs) -> Result<()> {
+    validate_login(&args.login)?;
+    validate_fields(&args.fields)?;
+    validate_fee_receiver(&ctx.accounts.fee_receiver)?;
+    require!(
+        args.additional_limit % settings::LIMIT_STEP == 0,
+        ErrCode::InvalidLimitIncrement
+    );
+
+    let (expected_pda, bump) = find_user_pda(ctx.program_id, &args.login);
+    require_keys_eq!(
+        expected_pda,
+        ctx.accounts.user_pda.key(),
+        ErrCode::InvalidPdaAddress
+    );
+    require!(
+        ctx.accounts.user_pda.owner == &Pubkey::default(),
+        ErrCode::UserAlreadyExists
+    );
+
+    let start_balance = settings::START_BONUS_LIMIT
+        .checked_add(args.additional_limit)
+        .ok_or(error!(ErrCode::MathOverflow))?;
+
+    let mut record = UserRecord {
+        created_at_ms: args.created_at_ms,
+        updated_at_ms: args.created_at_ms,
+        version: 0,
+        prev_hash: ZERO_HASH,
+        login: args.login.clone(),
+        root_key: args.root_key,
+        blockchain_key: args.fields.blockchain_key,
+        device_key: args.fields.device_key,
+        chain_number: args.fields.chain_number,
+        balance: start_balance,
+        is_server: args.fields.is_server,
+        server_key: args.fields.server_key,
+        server_address: args.fields.server_address.clone(),
+        connection_servers: args.fields.connection_servers.clone(),
+        trusted_count: args.fields.trusted_count,
+        signature: [0; 64],
+    };
+
+    let unsigned = serialize_unsigned_record(&record)?;
+    verify_record_signature(&record.root_key, &args.signature, &unsigned)?;
+    record.signature = vec_to_signature(&args.signature)?;
+
+    let serialized = serialize_full_record(&record)?;
+    require!(
+        serialized.len() <= settings::USER_PDA_SPACE,
+        ErrCode::RecordTooLarge
+    );
+    let padded = pad_to_fixed_size(serialized, settings::USER_PDA_SPACE)?;
+
+    let pda_seeds: &[&[u8]] = &[
+        settings::USER_PDA_SEED_PREFIX.as_bytes(),
+        args.login.as_bytes(),
+        &[bump],
+    ];
+    create_pda(
+        &ctx.accounts.user_pda,
+        &ctx.accounts.signer,
+        &ctx.accounts.system_program.to_account_info(),
+        ctx.program_id,
+        pda_seeds,
+        settings::USER_PDA_SPACE as u64,
+    )?;
+    write_to_pda(&ctx.accounts.user_pda, &padded)?;
+
+    let total_fee = settings::REGISTRATION_FEE_LAMPORTS
+        .checked_add(limit_fee_lamports(args.additional_limit)?)
+        .ok_or(error!(ErrCode::MathOverflow))?;
+    transfer_lamports(
+        &ctx.accounts.signer,
+        &ctx.accounts.fee_receiver,
+        &ctx.accounts.system_program.to_account_info(),
+        total_fee,
+    )?;
+
+    Ok(())
+}
+
+pub fn update_user_pda(ctx: Context<UpdateUserPda>, args: UpdateUserPdaArgs) -> Result<()> {
+    validate_login(&args.login)?;
+    validate_fields(&args.fields)?;
+    validate_fee_receiver(&ctx.accounts.fee_receiver)?;
+    require!(
+        args.additional_limit % settings::LIMIT_STEP == 0,
+        ErrCode::InvalidLimitIncrement
+    );
+
+    let (expected_pda, _) = find_user_pda(ctx.program_id, &args.login);
+    require_keys_eq!(
+        expected_pda,
+        ctx.accounts.user_pda.key(),
+        ErrCode::InvalidPdaAddress
+    );
+    require!(
+        ctx.accounts.user_pda.owner == ctx.program_id,
+        ErrCode::InvalidPdaAddress
+    );
+
+    let raw = safe_read_pda(&ctx.accounts.user_pda);
+    require!(!raw.is_empty(), ErrCode::EmptyPdaData);
+    let old_record = deserialize_record_from_pda(&raw)?;
+
+    require!(
+        old_record.login == args.login,
+        ErrCode::ImmutableFieldChanged
+    );
+    require!(
+        old_record.created_at_ms == args.created_at_ms,
+        ErrCode::ImmutableFieldChanged
+    );
+    require_keys_eq!(old_record.root_key, args.root_key, ErrCode::ImmutableFieldChanged);
+    require!(
+        args.version == old_record.version.saturating_add(1),
+        ErrCode::InvalidVersion
+    );
+
+    let expected_prev_hash = hash_unsigned_record(&old_record)?;
+    let provided_prev_hash = vec_to_hash32(&args.prev_hash)?;
+    require!(
+        expected_prev_hash == provided_prev_hash,
+        ErrCode::InvalidPrevHash
+    );
+
+    let new_balance = old_record
+        .balance
+        .checked_add(args.additional_limit)
+        .ok_or(error!(ErrCode::MathOverflow))?;
+    require!(new_balance >= old_record.balance, ErrCode::BalanceDecrease);
+
+    let mut new_record = UserRecord {
+        created_at_ms: old_record.created_at_ms,
+        updated_at_ms: args.updated_at_ms,
+        version: args.version,
+        prev_hash: provided_prev_hash,
+        login: old_record.login.clone(),
+        root_key: old_record.root_key,
+        blockchain_key: args.fields.blockchain_key,
+        device_key: args.fields.device_key,
+        chain_number: args.fields.chain_number,
+        balance: new_balance,
+        is_server: args.fields.is_server,
+        server_key: args.fields.server_key,
+        server_address: args.fields.server_address.clone(),
+        connection_servers: args.fields.connection_servers.clone(),
+        trusted_count: args.fields.trusted_count,
+        signature: [0; 64],
+    };
+
+    let unsigned = serialize_unsigned_record(&new_record)?;
+    verify_record_signature(&new_record.root_key, &args.signature, &unsigned)?;
+    new_record.signature = vec_to_signature(&args.signature)?;
+
+    let serialized = serialize_full_record(&new_record)?;
+    require!(
+        serialized.len() <= settings::USER_PDA_SPACE,
+        ErrCode::RecordTooLarge
+    );
+    let padded = pad_to_fixed_size(serialized, settings::USER_PDA_SPACE)?;
+    write_to_pda(&ctx.accounts.user_pda, &padded)?;
+
+    let topup_fee = limit_fee_lamports(args.additional_limit)?;
+    if topup_fee > 0 {
+        transfer_lamports(
+            &ctx.accounts.signer,
+            &ctx.accounts.fee_receiver,
+            &ctx.accounts.system_program.to_account_info(),
+            topup_fee,
+        )?;
+    }
+
+    Ok(())
+}
+
+fn serialize_unsigned_record(record: &UserRecord) -> Result<Vec<u8>> {
+    let login_bytes = record.login.as_bytes();
+    require!(login_bytes.len() <= u8::MAX as usize, ErrCode::InvalidLogin);
+
+    let server_address_bytes = record.server_address.as_bytes();
+    require!(
+        server_address_bytes.len() <= u8::MAX as usize,
+        ErrCode::InvalidRecordData
+    );
+    require!(
+        record.connection_servers.len() <= u8::MAX as usize,
+        ErrCode::InvalidRecordData
+    );
+
+    let mut out = Vec::new();
+    out.extend_from_slice(MAGIC);
+    out.push(FORMAT_MAJOR);
+    out.push(FORMAT_MINOR);
+    out.extend_from_slice(&0u16.to_le_bytes());
+
+    out.extend_from_slice(&record.created_at_ms.to_le_bytes());
+    out.extend_from_slice(&record.updated_at_ms.to_le_bytes());
+    out.extend_from_slice(&record.version.to_le_bytes());
+    out.extend_from_slice(&record.prev_hash);
+
+    out.push(login_bytes.len() as u8);
+    out.extend_from_slice(login_bytes);
+
+    out.extend_from_slice(record.root_key.as_ref());
+    out.extend_from_slice(record.blockchain_key.as_ref());
+    out.extend_from_slice(record.device_key.as_ref());
+
+    out.extend_from_slice(&record.chain_number.to_le_bytes());
+    out.extend_from_slice(&record.balance.to_le_bytes());
+
+    out.push(if record.is_server { 1 } else { 0 });
+    if record.is_server {
+        out.extend_from_slice(record.server_key.as_ref());
+        out.push(server_address_bytes.len() as u8);
+        out.extend_from_slice(server_address_bytes);
+    }
+
+    out.push(record.connection_servers.len() as u8);
+    for login in &record.connection_servers {
+        let bytes = login.as_bytes();
+        require!(bytes.len() <= u8::MAX as usize, ErrCode::InvalidRecordData);
+        out.push(bytes.len() as u8);
+        out.extend_from_slice(bytes);
+    }
+
+    out.push(record.trusted_count);
+    out.extend_from_slice(&RESERVED_BYTES);
+
+    let record_len = out
+        .len()
+        .checked_add(64)
+        .ok_or(error!(ErrCode::MathOverflow))?;
+    require!(record_len <= u16::MAX as usize, ErrCode::RecordTooLarge);
+    let len_bytes = (record_len as u16).to_le_bytes();
+    out[7] = len_bytes[0];
+    out[8] = len_bytes[1];
+
+    Ok(out)
+}
+
+fn serialize_full_record(record: &UserRecord) -> Result<Vec<u8>> {
+    let mut out = serialize_unsigned_record(record)?;
+    out.extend_from_slice(&record.signature);
+    Ok(out)
+}
+
+fn deserialize_record_from_pda(raw: &[u8]) -> Result<UserRecord> {
+    require!(raw.len() >= 9, ErrCode::InvalidRecordData);
+    require!(&raw[0..5] == MAGIC, ErrCode::InvalidRecordMagic);
+    require!(
+        raw[5] == FORMAT_MAJOR && raw[6] == FORMAT_MINOR,
+        ErrCode::InvalidRecordFormat
+    );
+
+    let record_len = u16::from_le_bytes([raw[7], raw[8]]) as usize;
+    require!(record_len >= 9 + 64, ErrCode::InvalidRecordLength);
+    require!(record_len <= raw.len(), ErrCode::InvalidRecordLength);
+
+    let useful = &raw[..record_len];
+    let mut cursor = 9usize;
+
+    let created_at_ms = read_u64(useful, &mut cursor)?;
+    let updated_at_ms = read_u64(useful, &mut cursor)?;
+    let version = read_u32(useful, &mut cursor)?;
+    let prev_hash = read_fixed_32(useful, &mut cursor)?;
+    let login = read_len_prefixed_string(useful, &mut cursor)?;
+
+    let root_key = Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?);
+    let blockchain_key = Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?);
+    let device_key = Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?);
+
+    let chain_number = read_u16(useful, &mut cursor)?;
+    let balance = read_u64(useful, &mut cursor)?;
+
+    let is_server = read_u8(useful, &mut cursor)? == 1;
+    let (server_key, server_address) = if is_server {
+        (
+            Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?),
+            read_len_prefixed_string(useful, &mut cursor)?,
+        )
+    } else {
+        (Pubkey::default(), String::new())
+    };
+
+    let connections_count = read_u8(useful, &mut cursor)? as usize;
+    let mut connection_servers = Vec::with_capacity(connections_count);
+    for _ in 0..connections_count {
+        connection_servers.push(read_len_prefixed_string(useful, &mut cursor)?);
+    }
+
+    let trusted_count = read_u8(useful, &mut cursor)?;
+    require!(
+        useful.get(cursor..cursor + 5) == Some(&RESERVED_BYTES),
+        ErrCode::InvalidRecordData
+    );
+    cursor += 5;
+
+    let signature = read_fixed_64(useful, &mut cursor)?;
+    require!(cursor == useful.len(), ErrCode::InvalidRecordLength);
+
+    Ok(UserRecord {
+        created_at_ms,
+        updated_at_ms,
+        version,
+        prev_hash,
+        login,
+        root_key,
+        blockchain_key,
+        device_key,
+        chain_number,
+        balance,
+        is_server,
+        server_key,
+        server_address,
+        connection_servers,
+        trusted_count,
+        signature,
+    })
+}
+
+fn hash_unsigned_record(record: &UserRecord) -> Result<[u8; 32]> {
+    let unsigned = serialize_unsigned_record(record)?;
+    let digest = Sha256::digest(unsigned);
+    let mut out = [0u8; 32];
+    out.copy_from_slice(&digest);
+    Ok(out)
+}
+
+fn verify_record_signature(root_key: &Pubkey, signature: &[u8], unsigned: &[u8]) -> Result<()> {
+    let sig_arr = vec_to_signature(signature)?;
+    let hash = Sha256::digest(unsigned);
+    let verify_key =
+        PublicKey::from_bytes(root_key.as_ref()).map_err(|_| error!(ErrCode::InvalidSignature))?;
+    let sig = Signature::from_bytes(&sig_arr).map_err(|_| error!(ErrCode::InvalidSignature))?;
+    verify_key
+        .verify(hash.as_slice(), &sig)
+        .map_err(|_| error!(ErrCode::InvalidSignature))?;
+    Ok(())
+}
+
+fn validate_login(login: &str) -> Result<()> {
+    require!(!login.is_empty(), ErrCode::InvalidLogin);
+    require!(login.len() <= 30, ErrCode::InvalidLogin);
+    for ch in login.chars() {
+        if !(ch.is_ascii_lowercase() || ch.is_ascii_digit() || ch == '_') {
+            return Err(error!(ErrCode::InvalidLogin));
+        }
+    }
+    Ok(())
+}
+
+fn validate_fields(fields: &UserMutableFields) -> Result<()> {
+    if fields.is_server {
+        require!(!fields.server_address.is_empty(), ErrCode::InvalidRecordData);
+        require!(
+            fields.server_address.as_bytes().len() <= u8::MAX as usize,
+            ErrCode::InvalidRecordData
+        );
+    } else {
+        require!(fields.server_address.is_empty(), ErrCode::InvalidRecordData);
+    }
+    require!(
+        fields.connection_servers.len() <= u8::MAX as usize,
+        ErrCode::InvalidRecordData
+    );
+    for login in &fields.connection_servers {
+        require!(!login.is_empty(), ErrCode::InvalidRecordData);
+        require!(login.as_bytes().len() <= u8::MAX as usize, ErrCode::InvalidRecordData);
+    }
+    Ok(())
+}
+
+fn validate_fee_receiver(fee_receiver: &AccountInfo) -> Result<()> {
+    let expected = Pubkey::from_str(settings::REGISTRATION_FEE_RECEIVER)
+        .map_err(|_| error!(ErrCode::InvalidFeeReceiver))?;
+    require_keys_eq!(expected, *fee_receiver.key, ErrCode::InvalidFeeReceiver);
+    Ok(())
+}
+
+fn transfer_lamports<'info>(
+    payer: &AccountInfo<'info>,
+    recipient: &AccountInfo<'info>,
+    system_program: &AccountInfo<'info>,
+    lamports: u64,
+) -> Result<()> {
+    if lamports == 0 {
+        return Ok(());
+    }
+    let ix = system_instruction::transfer(payer.key, recipient.key, lamports);
+    invoke(&ix, &[payer.clone(), recipient.clone(), system_program.clone()])?;
+    Ok(())
+}
+
+fn limit_fee_lamports(limit_delta: u64) -> Result<u64> {
+    let units = limit_delta / settings::LIMIT_STEP;
+    units
+        .checked_mul(settings::LAMPORTS_PER_LIMIT_STEP)
+        .ok_or(error!(ErrCode::MathOverflow))
+}
+
+fn find_user_pda(program_id: &Pubkey, login: &str) -> (Pubkey, u8) {
+    Pubkey::find_program_address(
+        &[settings::USER_PDA_SEED_PREFIX.as_bytes(), login.as_bytes()],
+        program_id,
+    )
+}
+
+fn pad_to_fixed_size(mut bytes: Vec<u8>, target_size: usize) -> Result<Vec<u8>> {
+    require!(bytes.len() <= target_size, ErrCode::RecordTooLarge);
+    bytes.resize(target_size, 0);
+    Ok(bytes)
+}
+
+fn vec_to_signature(input: &[u8]) -> Result<[u8; 64]> {
+    require!(input.len() == 64, ErrCode::InvalidSignature);
+    let mut out = [0u8; 64];
+    out.copy_from_slice(input);
+    Ok(out)
+}
+
+fn vec_to_hash32(input: &[u8]) -> Result<[u8; 32]> {
+    require!(input.len() == 32, ErrCode::InvalidPrevHash);
+    let mut out = [0u8; 32];
+    out.copy_from_slice(input);
+    Ok(out)
+}
+
+fn read_u8(data: &[u8], cursor: &mut usize) -> Result<u8> {
+    let v = *data.get(*cursor).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor += 1;
+    Ok(v)
+}
+
+fn read_u16(data: &[u8], cursor: &mut usize) -> Result<u16> {
+    let end = cursor
+        .checked_add(2)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    Ok(u16::from_le_bytes([slice[0], slice[1]]))
+}
+
+fn read_u32(data: &[u8], cursor: &mut usize) -> Result<u32> {
+    let end = cursor
+        .checked_add(4)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    Ok(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
+}
+
+fn read_u64(data: &[u8], cursor: &mut usize) -> Result<u64> {
+    let end = cursor
+        .checked_add(8)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    Ok(u64::from_le_bytes([
+        slice[0], slice[1], slice[2], slice[3], slice[4], slice[5], slice[6], slice[7],
+    ]))
+}
+
+fn read_fixed_32(data: &[u8], cursor: &mut usize) -> Result<[u8; 32]> {
+    let end = cursor
+        .checked_add(32)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    let mut out = [0u8; 32];
+    out.copy_from_slice(slice);
+    Ok(out)
+}
+
+fn read_fixed_64(data: &[u8], cursor: &mut usize) -> Result<[u8; 64]> {
+    let end = cursor
+        .checked_add(64)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    let mut out = [0u8; 64];
+    out.copy_from_slice(slice);
+    Ok(out)
+}
+
+fn read_len_prefixed_string(data: &[u8], cursor: &mut usize) -> Result<String> {
+    let len = read_u8(data, cursor)? as usize;
+    let end = cursor
+        .checked_add(len)
+        .ok_or(error!(ErrCode::InvalidRecordData))?;
+    let slice = data.get(*cursor..end).ok_or(error!(ErrCode::InvalidRecordData))?;
+    *cursor = end;
+    let value = std::str::from_utf8(slice).map_err(|_| error!(ErrCode::InvalidRecordData))?;
+    Ok(value.to_string())
+}

shine/scripts/devnet/README.md

@@ -0,0 +1,76 @@
+Devnet E2E тест: NFT-модуль + add_bonus
+
+Ветка содержит скрипты для проверки (NFT + add_bonus) в devnet.
+
+Скрипты:
+
+quick_devnet_e2e.js — создаёт 1 NFT и вызывает add_bonus.
+
+quick_devnet_e2e_multi.js — создаёт N NFT в коллекции.
+
+
+
+Подготовка окружения
+
+Установите зависимости:
+
+npm i @coral-xyz/anchor @solana/web3.js @solana/spl-token
+
+
+Создайте файл .env с переменными:
+
+
+ANCHOR_PROVIDER_URL=https://api.devnet.solana.com
+ANCHOR_WALLET=/Users/<user>/.config/solana/id.json
+PROGRAM_ID=qpgnAKhsXgPPaqQWfXhpme7UnG8GyStssuoSjF6Fzy3
+COLLECTION_MINT=<mint коллекции>
+
+ANCHOR_PROVIDER_URL=https://api.devnet.solana.com
+ANCHOR_WALLET=/Users/<user>/.config/solana/id.json
+PROGRAM_ID=<адрес shine_payments в devnet>
+COLLECTION_MINT=<mint коллекции>
+
+
+Пополните кошелёк тестовыми SOL:
+
+solana config set --url https://api.devnet.solana.com
+solana airdrop 2
+
+Запуск тестов:
+
+одиночный NFT:
+
+node quick_devnet_e2e.js
+
+
+несколько NFT:
+
+node quick_devnet_e2e_multi.js 3
+
+
+
+Проверка результата
+
+В выводе будут строки:
+
+add_bonus() tx: <signature>
+
+NFT mint: <address>
+
+
+
+Откройте транзакцию или mint в Solana Explorer
+
+
+Убедитесь:
+
+Verified Collection совпадает с вашим COLLECTION_MINT
+
+У каждого NFT Supply = 1
+
+Аккаунт получателя (ATA) помечен как frozen
+
+
+
+
+⚠️ Повторный запуск может вернуть ошибку PdaAlreadyExists это нормально, так как PDA уже инициализирован.

shine/scripts/devnet/quick_devnet_e2e.js

@@ -0,0 +1,285 @@
+const anchor = require("@coral-xyz/anchor");
+const {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} = require("@solana/web3.js");
+const {
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createMint,
+  getAccount,
+} = require("@solana/spl-token");
+const crypto = require("crypto");
+
+// Адрес программы метаданных Metaplex (фиксированный)
+const METAPLEX_TOKEN_METADATA_PROGRAM_ID = new PublicKey(
+  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+);
+
+// ────────────────────────────────
+// Утилиты
+// ────────────────────────────────
+const BASE58_RE = /[1-9A-HJ-NP-Za-km-z]{32,}/g;
+
+function mustEnv(name) {
+  const v = (process.env[name] || "").trim();
+  if (!v) throw new Error(`Переменная окружения ${name} не задана`);
+  return v;
+}
+
+function pickBase58(raw, name) {
+  const m = (raw || "").toString().match(BASE58_RE);
+  if (!m) throw new Error(`${name} не найден/невалиден: "${raw}"`);
+  return m[0];
+}
+
+// Anchor discriminator: sha256("global:<ix_name>") первые 8 байт
+function disc8(ixName) {
+  const preimage = `global:${ixName}`;
+  const h = crypto.createHash("sha256").update(preimage).digest();
+  return h.subarray(0, 8);
+}
+
+function u64le(n) {
+  const bn = BigInt(n.toString());
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(bn);
+  return buf;
+}
+
+// Надёжная отправка транзакций с ретраями при «Blockhash not found»
+async function sendTx(provider, tx, signers = []) {
+  const conn = provider.connection;
+  let lastErr;
+
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash(
+        "confirmed"
+      );
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = provider.wallet.publicKey;
+
+      for (const s of signers) tx.partialSign(s);
+
+      const signed = await provider.wallet.signTransaction(tx);
+
+      const sig = await conn.sendRawTransaction(signed.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: "confirmed",
+        maxRetries: 3,
+      });
+
+      await conn.confirmTransaction(
+        { signature: sig, blockhash, lastValidBlockHeight },
+        "confirmed"
+      );
+
+      return sig;
+    } catch (e) {
+      lastErr = e;
+      const msg = String(e?.message || e).toLowerCase();
+      if (msg.includes("blockhash not found") || msg.includes("expired")) {
+        // пробуем ещё раз со свежим blockhash
+        continue;
+      }
+      throw e;
+    }
+  }
+
+  throw lastErr;
+}
+
+// ────────────────────────────────
+// Основной сценарий
+// ────────────────────────────────
+(async () => {
+  // Провайдер / окружение
+  const RPC = mustEnv("ANCHOR_PROVIDER_URL");
+  const WALLET_PATH = mustEnv("ANCHOR_WALLET");
+  const PROGRAM_ID = new PublicKey(
+    pickBase58(mustEnv("PROGRAM_ID"), "PROGRAM_ID")
+  );
+  const COLLECTION_MINT = new PublicKey(
+    pickBase58(mustEnv("COLLECTION_MINT"), "COLLECTION_MINT")
+  );
+
+  const provider = anchor.AnchorProvider.env(); // читает из ENV
+  anchor.setProvider(provider);
+  const conn = provider.connection;
+  const wallet = provider.wallet;
+
+  console.log("────────────────────────────────────────────────────────");
+  console.log("RPC                  :", RPC);
+  console.log("Wallet               :", wallet.publicKey.toBase58());
+  console.log("Program ID           :", PROGRAM_ID.toBase58());
+  console.log("Collection mint      :", COLLECTION_MINT.toBase58());
+  console.log(
+    "TokenMetadata PID    :",
+    METAPLEX_TOKEN_METADATA_PROGRAM_ID.toBase58()
+  );
+  console.log("ATA Program PID      :", ASSOCIATED_TOKEN_PROGRAM_ID.toBase58());
+  console.log("────────────────────────────────────────────────────────");
+
+  // 1) INIT (создаёт PDA состояния)
+  const [statePda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("shine_investments_state")],
+    PROGRAM_ID
+  );
+
+  const initIx = new TransactionInstruction({
+    programId: PROGRAM_ID,
+    keys: [
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: true }, // payer
+      { pubkey: statePda, isSigner: false, isWritable: true }, // state_pda
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    data: Buffer.from([...disc8("init")]), // без аргументов
+  });
+
+  try {
+    const sigInit = await sendTx(provider, new Transaction().add(initIx));
+    console.log(
+      "init() tx:",
+      sigInit,
+      `https://explorer.solana.com/tx/${sigInit}?cluster=devnet`
+    );
+  } catch (e) {
+    console.log("init(): возможно уже выполнен ->", e.message);
+  }
+
+  // 2) Локально создаём mint нового NFT и ATA получателя
+  const mintPubkey = await createMint(
+    conn,
+    wallet.payer,
+    wallet.publicKey,
+    wallet.publicKey,
+    0
+  );
+  console.log("NFT mint:", mintPubkey.toBase58());
+
+  const recipientOwner = wallet.publicKey;
+  const recipientAta = await getAssociatedTokenAddress(
+    mintPubkey,
+    recipientOwner
+  );
+  const ataInfo = await conn.getAccountInfo(recipientAta);
+  if (!ataInfo) {
+    const createAtaIx = createAssociatedTokenAccountInstruction(
+      wallet.publicKey,
+      recipientAta,
+      recipientOwner,
+      mintPubkey
+    );
+    const sigAta = await sendTx(
+      provider,
+      new Transaction().add(createAtaIx)
+    );
+    console.log("Created ATA:", recipientAta.toBase58(), sigAta);
+  } else {
+    console.log("ATA exists:", recipientAta.toBase58());
+  }
+
+  // PDA для metadata/master edition нашего нового NFT
+  const [metadataPda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      METAPLEX_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      mintPubkey.toBuffer(),
+    ],
+    METAPLEX_TOKEN_METADATA_PROGRAM_ID
+  );
+  const [masterEditionPda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      METAPLEX_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      mintPubkey.toBuffer(),
+      Buffer.from("edition"),
+    ],
+    METAPLEX_TOKEN_METADATA_PROGRAM_ID
+  );
+
+  // PDA коллекции (metadata/master edition)
+  const [collectionMetadataPda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      METAPLEX_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      COLLECTION_MINT.toBuffer(),
+    ],
+    METAPLEX_TOKEN_METADATA_PROGRAM_ID
+  );
+  const [collectionMasterEditionPda] = PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("metadata"),
+      METAPLEX_TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+      COLLECTION_MINT.toBuffer(),
+      Buffer.from("edition"),
+    ],
+    METAPLEX_TOKEN_METADATA_PROGRAM_ID
+  );
+
+  // 3) add_bonus(investor: Pubkey, amount: u64) — raw-инструкция
+  // Порядок аккаунтов должен совпасть с #[derive(Accounts)] AddBonusCtx:
+  // signer(Signer), state_pda(mut), mint_pda(mut), recipient_ata(mut), recipient_owner,
+  // collection_mint, collection_metadata_pda(mut), collection_master_edition_pda(mut),
+  // collection_update_authority(Signer), metadata_pda(mut), master_edition_pda(mut),
+  // token_metadata_program, token_program, associated_token_program, system_program
+  const investor = recipientOwner;
+  const amount = 123_000_000n; // u64
+
+  const addBonusData = Buffer.concat([
+    disc8("add_bonus"),
+    investor.toBuffer(),
+    u64le(amount),
+  ]);
+
+  const addBonusIx = new TransactionInstruction({
+    programId: PROGRAM_ID,
+    keys: [
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: false }, // signer
+      { pubkey: statePda, isSigner: false, isWritable: true }, // state_pda
+      { pubkey: mintPubkey, isSigner: false, isWritable: true }, // mint_pda
+      { pubkey: recipientAta, isSigner: false, isWritable: true }, // recipient_ata
+      { pubkey: recipientOwner, isSigner: false, isWritable: false }, // recipient_owner
+      { pubkey: COLLECTION_MINT, isSigner: false, isWritable: false }, // collection_mint
+      { pubkey: collectionMetadataPda, isSigner: false, isWritable: true }, // collection_metadata_pda
+      { pubkey: collectionMasterEditionPda, isSigner: false, isWritable: true }, // collection_master_edition_pda
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: false }, // collection_update_authority
+      { pubkey: metadataPda, isSigner: false, isWritable: true }, // metadata_pda
+      { pubkey: masterEditionPda, isSigner: false, isWritable: true }, // master_edition_pda
+      { pubkey: METAPLEX_TOKEN_METADATA_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    data: addBonusData,
+  });
+
+  const sig = await sendTx(provider, new Transaction().add(addBonusIx));
+  console.log(
+    "add_bonus() tx:",
+    sig,
+    `https://explorer.solana.com/tx/${sig}?cluster=devnet`
+  );
+
+  // 4) простые проверки
+  const acc = await getAccount(conn, recipientAta);
+  console.log("isFrozen (ATA):", acc.isFrozen);
+  if (!acc.isFrozen) throw new Error("Ожидали заморозку ATA после add_bonus()");
+
+  const mdInfo = await conn.getAccountInfo(metadataPda);
+  if (!mdInfo || mdInfo.data.length === 0)
+    throw new Error("Metadata PDA отсутствует или пуст");
+
+  console.log(
+    "Готово: raw-инструкции прошли, NFT создан/верифицирован и ATA заморожен"
+  );
+})().catch((e) => {
+  console.error("Ошибка e2e:", e);
+  process.exit(1);
+});

shine/scripts/devnet/quick_devnet_e2e_multi.js

@@ -0,0 +1,205 @@
+const anchor = require("@coral-xyz/anchor");
+const {
+  Connection,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} = require("@solana/web3.js");
+const {
+  getAssociatedTokenAddress,
+  createAssociatedTokenAccountInstruction,
+  TOKEN_PROGRAM_ID,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  createMint,
+  getAccount,
+} = require("@solana/spl-token");
+const crypto = require("crypto");
+
+// Programs
+const MPL = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+
+// utils
+const BASE58_RE = /[1-9A-HJ-NP-Za-km-z]{32,}/g;
+function mustEnv(name) {
+  const v = (process.env[name] || "").trim();
+  if (!v) throw new Error(`ENV ${name} is required`);
+  return v;
+}
+function pickBase58(raw, name) {
+  const m = (raw || "").toString().match(BASE58_RE);
+  if (!m) throw new Error(`${name} invalid: "${raw}"`);
+  return m[0];
+}
+function disc8(name) {
+  const preimage = `global:${name}`;
+  const h = crypto.createHash("sha256").update(preimage).digest();
+  return h.subarray(0, 8);
+}
+function u64le(n) {
+  const bn = BigInt(n.toString());
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(bn);
+  return buf;
+}
+async function sendTx(provider, tx, signers = []) {
+  const conn = provider.connection;
+  const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash("confirmed");
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = provider.wallet.publicKey;
+  for (const s of signers) tx.partialSign(s);
+  const raw = await provider.wallet.signTransaction(tx);
+  const sig = await conn.sendRawTransaction(raw.serialize(), {
+    skipPreflight: false,
+    preflightCommitment: "confirmed",
+    maxRetries: 3,
+  });
+  await conn.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, "confirmed");
+  return sig;
+}
+
+(async () => {
+  const count = Number(process.argv[2] || "3"); // сколько NFT сделать
+  const RPC = mustEnv("ANCHOR_PROVIDER_URL");
+  const PROGRAM_ID = new PublicKey(pickBase58(mustEnv("PROGRAM_ID"), "PROGRAM_ID"));
+  const COLLECTION_MINT = new PublicKey(pickBase58(mustEnv("COLLECTION_MINT"), "COLLECTION_MINT"));
+
+  const provider = anchor.AnchorProvider.env();
+  anchor.setProvider(provider);
+  const conn = provider.connection;
+  const wallet = provider.wallet;
+
+  console.log("────────────────────────────────────────────────────────");
+  console.log("RPC                  :", RPC);
+  console.log("Wallet               :", wallet.publicKey.toBase58());
+  console.log("Program ID           :", PROGRAM_ID.toBase58());
+  console.log("Collection mint      :", COLLECTION_MINT.toBase58());
+  console.log("TokenMetadata PID    :", MPL.toBase58());
+  console.log("ATA Program PID      :", ASSOCIATED_TOKEN_PROGRAM_ID.toBase58());
+  console.log("Count                :", count);
+  console.log("────────────────────────────────────────────────────────");
+
+  // ensure init (если уже есть — просто пропустим)
+  const [statePda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("shine_investments_state")],
+    PROGRAM_ID
+  );
+  const initIx = new TransactionInstruction({
+    programId: PROGRAM_ID,
+    keys: [
+      { pubkey: wallet.publicKey, isSigner: true, isWritable: true }, // payer
+      { pubkey: statePda, isSigner: false, isWritable: true },        // state_pda
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    ],
+    data: Buffer.from([...disc8("init")]),
+  });
+  try {
+    const sigInit = await sendTx(provider, new Transaction().add(initIx));
+    console.log("init() tx:", sigInit, `https://explorer.solana.com/tx/${sigInit}?cluster=devnet`);
+  } catch (e) {
+    console.log("init(): возможно уже выполнен ->", e.message);
+  }
+
+  const minted = [];
+
+  for (let i = 0; i < count; i++) {
+    // 1) создаём новый mint (NFT)
+    const mintPubkey = await createMint(conn, wallet.payer, wallet.publicKey, wallet.publicKey, 0);
+    console.log(`\n[${i + 1}/${count}] NFT mint:`, mintPubkey.toBase58());
+
+    // 2) создаём ATA при необходимости
+    const recipientOwner = wallet.publicKey;
+    const recipientAta = await getAssociatedTokenAddress(mintPubkey, recipientOwner);
+    const ataInfo = await conn.getAccountInfo(recipientAta);
+    if (!ataInfo) {
+      const createAtaIx = createAssociatedTokenAccountInstruction(
+        wallet.publicKey, recipientAta, recipientOwner, mintPubkey
+      );
+      const sigAta = await sendTx(provider, new Transaction().add(createAtaIx));
+      console.log("  ATA created:", recipientAta.toBase58(), sigAta);
+    } else {
+      console.log("  ATA exists:", recipientAta.toBase58());
+    }
+
+    // PDA для нашего NFT (metadata/master edition)
+    const [metadataPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), MPL.toBuffer(), mintPubkey.toBuffer()],
+      MPL
+    );
+    const [masterEditionPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), MPL.toBuffer(), mintPubkey.toBuffer(), Buffer.from("edition")],
+      MPL
+    );
+
+    // PDA коллекции
+    const [collectionMetadataPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), MPL.toBuffer(), COLLECTION_MINT.toBuffer()],
+      MPL
+    );
+    const [collectionMasterEditionPda] = PublicKey.findProgramAddressSync(
+      [Buffer.from("metadata"), MPL.toBuffer(), COLLECTION_MINT.toBuffer(), Buffer.from("edition")],
+      MPL
+    );
+
+    // 3) add_bonus(investor, amount)
+    const investor = recipientOwner;
+    // Для наглядности — разные суммы
+    const amount = BigInt(100_000_000 + i * 10_000_000); // 100M, 110M, 120M...
+
+    const addBonusData = Buffer.concat([
+      disc8("add_bonus"),
+      investor.toBuffer(),
+      u64le(amount),
+    ]);
+
+    const addBonusIx = new TransactionInstruction({
+      programId: PROGRAM_ID,
+      keys: [
+        { pubkey: wallet.publicKey, isSigner: true,  isWritable: false }, // signer
+        { pubkey: statePda,        isSigner: false, isWritable: true  }, // state_pda
+        { pubkey: mintPubkey,      isSigner: false, isWritable: true  }, // mint_pda
+        { pubkey: recipientAta,    isSigner: false, isWritable: true  }, // recipient_ata
+        { pubkey: recipientOwner,  isSigner: false, isWritable: false }, // recipient_owner
+        { pubkey: COLLECTION_MINT, isSigner: false, isWritable: false }, // collection_mint
+        { pubkey: collectionMetadataPda,      isSigner: false, isWritable: true  },
+        { pubkey: collectionMasterEditionPda, isSigner: false, isWritable: true  },
+        { pubkey: wallet.publicKey, isSigner: true,  isWritable: false }, // collection_update_authority
+        { pubkey: metadataPda,      isSigner: false, isWritable: true  },
+        { pubkey: masterEditionPda, isSigner: false, isWritable: true  },
+        { pubkey: MPL,                       isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID,          isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID,isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId,   isSigner: false, isWritable: false },
+      ],
+      data: addBonusData,
+    });
+
+    const sig = await sendTx(provider, new Transaction().add(addBonusIx));
+    console.log("  add_bonus() tx:", sig, `https://explorer.solana.com/tx/${sig}?cluster=devnet`);
+
+    // 4) проверки
+    const acc = await getAccount(conn, recipientAta);
+    console.log("  ATA frozen:", acc.isFrozen);
+
+    minted.push({
+      mint: mintPubkey.toBase58(),
+      ata: recipientAta.toBase58(),
+      addBonusSig: sig,
+      metadataPda: metadataPda.toBase58(),
+    });
+  }
+
+  console.log("\n==================== SUMMARY ====================");
+  console.log("Wallet:", wallet.publicKey.toBase58());
+  console.log("Collection:", COLLECTION_MINT.toBase58());
+  console.table(minted);
+  console.log("Открой каждую сигнатуру (add_bonus tx) и mint в Explorer:");
+  minted.forEach((m, i) => {
+    console.log(`[${i + 1}] Mint: https://explorer.solana.com/address/${m.mint}?cluster=devnet`);
+    console.log(`    TX : https://explorer.solana.com/tx/${m.addBonusSig}?cluster=devnet`);
+  });
+  console.log("=================================================");
+})().catch((e) => {
+  console.error("Ошибка:", e);
+  process.exit(1);
+});

shine/tests/shine.ts

@@ -0,0 +1,16 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Program } from "@coral-xyz/anchor";
+import { Shine } from "../target/types/shine";
+
+describe("shine", () => {
+  // Configure the client to use the local cluster.
+  anchor.setProvider(anchor.AnchorProvider.env());
+
+  const program = anchor.workspace.shine as Program<Shine>;
+
+  it("Is initialized!", async () => {
+    // Add your test here.
+    const tx = await program.methods.initialize().rpc();
+    console.log("Your transaction signature", tx);
+  });
+});

shine/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "types": ["mocha", "chai"],
+    "typeRoots": ["./node_modules/@types"],
+    "lib": ["es2015"],
+    "module": "commonjs",
+    "target": "es6",
+    "esModuleInterop": true
+  }
+}

shine/validator.log

@@ -0,0 +1,3 @@
+Ledger location: test-ledger
+Log: test-ledger/validator.log
+Initializing...

solana-shine-client-lib/.gitignore

@@ -0,0 +1,42 @@
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

solana-shine-client-lib/.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

solana-shine-client-lib/.idea/gradle.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleHome" value="" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+            <option value="$PROJECT_DIR$/solana-shine-lib" />
+          </set>
+        </option>
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

solana-shine-client-lib/.idea/misc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="FrameworkDetectionExcludesConfiguration">
+    <file type="web" url="file://$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

solana-shine-client-lib/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

solana-shine-client-lib/build.gradle

@@ -0,0 +1,46 @@
+plugins {
+    id 'java'
+}
+
+apply plugin: 'java'
+
+group = 'com.shine'
+version = '1.0.0'
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+tasks.withType(Jar) {
+    manifest {
+        attributes(
+                'Implementation-Title': 'solana-shine-lib',   // или solana-shine-client-lib
+                'Implementation-Version': version
+        )
+    }
+}
+
+repositories {
+    mavenCentral()
+    flatDir {
+        dirs 'libs'
+    }
+}
+
+dependencies {
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+
+    implementation project(':solana-shine-lib')
+    implementation 'com.google.code.gson:gson:2.10.1'
+  //  implementation "com.mmorrell:solanaj:1.15.1"
+
+}
+
+test {
+    useJUnitPlatform()
+}
+
+
+

solana-shine-client-lib/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Fri Jun 13 15:16:43 MSK 2025
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

solana-shine-client-lib/gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

solana-shine-client-lib/gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

solana-shine-client-lib/settings.gradle

@@ -0,0 +1,2 @@
+rootProject.name = 'solana-shine-client-lib'
+include 'solana-shine-lib'

solana-shine-client-lib/solana-shine-lib/build.gradle

@@ -0,0 +1,56 @@
+plugins {
+    id 'java'
+}
+
+group = 'me.shineup'
+version = '1.0'
+
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+repositories {
+    mavenCentral()
+    flatDir {
+        dirs 'libs'
+    }
+}
+
+dependencies {
+    // были стандартные
+    testImplementation platform('org.junit:junit-bom:5.10.0')
+    testImplementation 'org.junit.jupiter:junit-jupiter'
+
+    // шифрование нужна
+    implementation 'org.bouncycastle:bcprov-jdk15on:1.70'
+
+//    implementation 'com.squareup.okhttp3:okhttp:4.12.0'   // запросы по сети
+    //солана
+    implementation "com.mmorrell:solanaj:1.15.1"
+
+//    implementation 'org.bitcoinj:bitcoinj-core:0.15.10'
+//    implementation 'com.squareup.moshi:moshi:1.13.0'
+
+
+//    implementation 'com.mmorrell:solanaj:1.20.4'     - старые соланы не нужны
+//    implementation name: 'solanaj-1.20.4'            - старые соланы не нужны
+
+
+
+    // Logging
+    implementation 'org.slf4j:slf4j-api:1.7.36'
+    implementation 'ch.qos.logback:logback-classic:1.2.11'
+
+
+    implementation 'com.google.code.gson:gson:2.10.1'
+
+}
+
+test {
+    useJUnitPlatform()
+}
+
+
+
+

solana-shine-client-lib/solana-shine-lib/src/main/java/TODO.txt

@@ -0,0 +1,9 @@
+Что ещё надо сделать по библиотеке
+
+1. Сделать более рандомное создание пар ключей.  (тк я три из трёх угадал в девнет!!!)
+
+2. Доделат обработку ошибок при вызове функции ( наверно уже в UI надо отлавливать ексепшены которые возвращает нода при препроверки вызова функции)
+
+  2.5 метод проверки что транзакция прям точно добавлена в систему. (хотя нужен ли он??. Тк пользователь добавился значет уже всё хорошо :)  )
+
+3. Исправить перевод денег (тк он не работает после перехода на старую библиотеку)

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaSettings.java

@@ -0,0 +1,42 @@
+package me.shineup.solana;
+
+import me.shineup.solana.config.Const;
+
+/**
+ * Настройки подключения к Solana.
+ * Позволяет выбирать RPC-сервер (локальный, тестовая сеть или произвольный).
+ */
+public class SolanaSettings {
+
+    /**
+     * Устанавливает локальный RPC-адрес (например, http://127.0.0.1:8899).
+     */
+    public static void setRpcUrlLocal() {
+        Const.RPC_URL = Const.LOCAL_RPC_URL;
+    }
+
+    /**
+     * Устанавливает RPC-адрес тестовой сети Solana (https://api.testnet.solana.com).
+     */
+    public static void setRpcUrlTestNet() {
+        Const.RPC_URL = "https://api.testnet.solana.com"; // или Const.TESTNET_RPC_URL
+    }
+
+    /**
+     * Устанавливает пользовательский RPC-адрес.
+     *
+     * @param url Строка с адресом RPC-сервера
+     */
+    public static void setRpcUrl(String url) {
+        Const.RPC_URL = url;
+    }
+
+    /**
+     * Получает текущий установленный RPC-адрес.
+     *
+     * @return строка с текущим RPC-URL
+     */
+    public static String getRpcUrl() {
+        return Const.RPC_URL;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaTxWatcher.java

@@ -0,0 +1,218 @@
+package me.shineup.solana;
+
+
+import me.shineup.solana.internal.utils.resultChecker.TransactionStatusHelper;
+import me.shineup.solana.model.TxStatus;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * <h2>SolanaTxWatcher</h2>
+ * <p>
+ * Класс-наблюдатель за одной транзакцией сети Solana.
+ * Он:
+ * <ul>
+ *   <li>Хранит подпись (signature) и фиксирует момент создания объекта.</li>
+ *   <li>Через {@link #updateStatus()} опрашивает RPC (используя {@link TransactionStatusHelper})
+ *       и обновляет внутренний статус.</li>
+ *   <li>Через {@link #shouldRetry()} сообщает, надо ли продолжать опрос (с учётом таймаута,
+ *       лимита неудачных попыток и финального статуса).</li>
+ *   <li>Через {@link #isSuccess()} указывает, прошла ли транзакция успешно.</li>
+ * </ul>
+ *
+ * <h3>Пример использования</h3>
+ *
+ * <pre>{@code
+ * SolanaTxWatcher watcher = new SolanaTxWatcher("5QgV...sig");
+ *
+ * while (watcher.shouldRetry()) {        // ◀ проверяем, нужно ли ещё опрашивать
+ *     watcher.updateStatus();            // ◀ запрашиваем статус через RPC
+ *     System.out.println(
+ *         watcher.getStatus() + " | " +  // ◀ печатаем статус
+ *         watcher.getStatusComment());
+ *     Thread.sleep(SolanaTxWatcher.getRetryIntervalMs()); // ◀ ждём секунду
+ * }
+ *
+ * if (watcher.isSuccess()) {
+ *     System.out.println("✅ Транзакция прошла успешно!");
+ * } else {
+ *     System.out.println("⛔ Завершили слежение без успеха.");
+ * }
+ * }</pre>
+
+ */
+public class SolanaTxWatcher {
+
+    /* ---------- НАСТРАИВАЕМЫЕ КОНСТАНТЫ ---------- */
+
+    /** Максимальное время слежения (мс). */
+    private static final long TIMEOUT_MS = 30_000;
+
+    /** Допустимое количество подряд статусов UNKNOWN / NETWORK_ERROR. */
+    private static final int MAX_FAILED_ATTEMPTS = 3;
+
+    /** Рекомендуемый интервал (мс) между вызовами {@link #updateStatus()}. */
+    private static final long RETRY_INTERVAL_MS = 1_000;
+
+    /* ---------- ПОЛЯ ЭКЗЕМПЛЯРА ---------- */
+
+    /** Подпись (signature) транзакции. */
+    private final String signature;
+
+    /** Время создания объекта (Unix-millis). */
+    private final long startTimeMs;
+
+    /** Кол-во подряд «слабых» ошибок (UNKNOWN / NETWORK_ERROR). */
+    private int failedAttempts;
+
+    /** Флаг: нужно ли ещё опрашивать RPC. */
+    private boolean needRetry;
+
+    /** Флаг: успешна ли транзакция (устанавливается при FINALIZED_SUCCESS). */
+    private boolean success;
+
+    /** Текущий статус из {@link TxStatus}. */
+    private TxStatus status;
+
+    /* ---------- ЧЕЛОВЕКО-ЧИТАЕМЫЕ ОПИСАНИЯ СТАТУСОВ ---------- */
+
+    private static final Map<TxStatus, String> COMMENTS = new HashMap<>();
+    static {
+        COMMENTS.put(TxStatus.NOT_FOUND,
+                "Подпись не дошла до RPC — ждём появления.");
+        COMMENTS.put(TxStatus.PROCESSED,
+                "Принята в обработку — ожидаем включения в блок.");
+        COMMENTS.put(TxStatus.CONFIRMED,
+                "Уже в блоке — ждём финализации.");
+        COMMENTS.put(TxStatus.FINALIZED_SUCCESS,
+                "Финализирована успешно.");
+        COMMENTS.put(TxStatus.FINALIZED_ERROR,
+                "Финализирована с ошибкой.");
+        COMMENTS.put(TxStatus.UNKNOWN,
+                "Неизвестная ошибка RPC/парсинга.");
+        COMMENTS.put(TxStatus.NETWORK_ERROR,
+                "Сбой сети или RPC недоступен.");
+    }
+
+    /* ---------- КОНСТРУКТОР ---------- */
+
+    /**
+     * Создаёт watcher для указанной подписи.
+     *
+     * @param signature подпись транзакции (Base58).
+     */
+    public SolanaTxWatcher(String signature) {
+        this.signature      = signature;
+        this.startTimeMs    = System.currentTimeMillis();
+        this.failedAttempts = 0;
+        this.needRetry      = true;                      // по умолчанию пытаемся
+        this.success        = false;                    // успех пока не достигнут
+        this.status         = TxStatus.NOT_FOUND; // стартовый
+    }
+
+    /* ---------- ГЕТТЕРЫ ---------- */
+
+    /** @return подпись транзакции. */
+    public String getSignature() { return signature; }
+
+    /** @return время создания watcher’а (Unix-millis). */
+    public long getStartTimeMs() { return startTimeMs; }
+
+    /** @return текущий статус. */
+    public TxStatus getStatus() { return status; }
+
+    /** @return true, если транзакция финализирована без ошибок. */
+    public boolean isSuccess() { return success; }
+
+    /** @return кол-во подряд неудачных (UNKNOWN/NETWORK_ERROR) попыток. */
+    public int getFailedAttempts() { return failedAttempts; }
+
+    /** @return человеко-читаемый комментарий к текущему статусу. */
+    public String getStatusComment() {
+        return COMMENTS.getOrDefault(status, "");
+    }
+
+    /* ---------- ОСНОВНОЙ МЕТОД ОПРОСА ---------- */
+
+    /**
+     * Запрашивает актуальный статус транзакции через {@link TransactionStatusHelper}
+     * и обновляет внутренние поля.
+     * <p>— При промежуточных статусах (NOT_FOUND / PROCESSED / CONFIRMED)
+     *     счётчик ошибок сбрасывается.<br>
+     * — При {@code FINALIZED_SUCCESS} или {@code FINALIZED_ERROR}
+     *     флаг {@link #needRetry} переводится в {@code false}.<br>
+     * — При {@code UNKNOWN} или {@code NETWORK_ERROR}
+     *     счётчик ошибок увеличивается; если превышен лимит — дальнейший опрос прекращается.
+     */
+    public void updateStatus() {
+        if (!needRetry) return; // уже решено не опрашивать
+
+        TxStatus newStatus =
+                TransactionStatusHelper.getTxStatus(signature);
+
+        switch (newStatus) {
+
+            case NOT_FOUND:
+            case PROCESSED:
+            case CONFIRMED:
+                failedAttempts = 0;       // успешное промежуточное обновление
+                break;
+
+            case FINALIZED_SUCCESS:
+                success    = true;
+                needRetry  = false;       // финальный успех
+                break;
+
+            case FINALIZED_ERROR:
+                success    = false;
+                needRetry  = false;       // финальный провал
+                break;
+
+            case UNKNOWN:
+            case NETWORK_ERROR:
+                failedAttempts++;
+                if (failedAttempts > MAX_FAILED_ATTEMPTS) {
+                    needRetry = false;    // слишком много ошибок — прекращаем
+                }
+                break;
+        }
+
+        status = newStatus;               // сохраняем новый статус
+    }
+
+    /* ---------- РЕШЕНИЕ: НУЖНО ЛИ ПОВТОРЯТЬ ---------- */
+
+    /**
+     * @return {@code true}, если можно и стоит делать ещё один запрос статуса.<br>
+     *         {@code false} — если достигнут финальный статус, превышен таймаут
+     *         или лимит неудачных попыток.
+     */
+    public boolean shouldRetry() {
+        if (!needRetry) return false;                     // наш флаг запрещает
+        long elapsed = System.currentTimeMillis() - startTimeMs;
+        if (elapsed > TIMEOUT_MS) {                       // вышли за таймаут
+            needRetry = false;
+            return false;
+        }
+        return true;
+    }
+
+    /* ---------- ВСПОМОГАТЕЛЬНОЕ ---------- */
+
+    /** @return рекомендуемую задержку (мс) между опросами. */
+    public static long getRetryIntervalMs() { return RETRY_INTERVAL_MS; }
+
+    @Override
+    public String toString() {
+        return String.format("[%s] sig=%s | status=%s | needRetry=%s | success=%s | attempts=%d | %s",
+                Instant.ofEpochMilli(startTimeMs),
+                signature,
+                status,
+                needRetry,
+                success,
+                failedAttempts,
+                getStatusComment());
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaWrapper.java

@@ -0,0 +1,88 @@
+package me.shineup.solana;
+
+import me.shineup.solana.internal.callSolanaFunc.RegisterUser.RegisterUserWithOneDev;
+import me.shineup.solana.model.TxStatus;
+import me.shineup.solana.model.UserById;
+import me.shineup.solana.internal.readFromSolana.userById.UserByIdReader;
+import me.shineup.solana.model.UserByLogin;
+import me.shineup.solana.internal.readFromSolana.userByLogin.UserByLoginReader;
+import me.shineup.solana.internal.standartActions.airDrops.SolanaAirdrop;
+import me.shineup.solana.internal.standartActions.balanse.SolanaBalanceChecker;
+import me.shineup.solana.internal.standartActions.keysGenerator.KeyPairBase58;
+import me.shineup.solana.internal.standartActions.keysGenerator.SolanaKeyGeneratorManual;
+import me.shineup.solana.internal.standartActions.transfer.SolanaTransfer;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.resultChecker.TransactionStatusHelper;
+
+public class SolanaWrapper {
+
+    /** Получает баланс по публичному ключу */
+    public static long getBalance(String publicKey) throws Exception{
+        return SolanaBalanceChecker.getBalance(publicKey);
+    }
+
+    /** Запрашивает Airdrop на указанный публичный ключ */
+    public static String requestAirdrop(String publicKey, long lamports) throws Exception{
+        return SolanaAirdrop.requestAirdrop(publicKey, lamports);
+    }
+
+    /** Обёртка для перевода lamports между двумя публичными ключами (оба ключа — в base58, приватный — отправителя). */
+//    public static String sendLamports(String fromBase58Secret, String toBase58Pubkey, long lamports) throws Exception {
+//        return SolanaTransfer.sendSol(fromBase58Secret, toBase58Pubkey, lamports);
+//    }
+
+    /** Генерирует новый Ed25519-кошелёк (ключи Solana) */
+    public static KeyPairBase58 generateNewWallet()  throws Exception{   // todo возмаожно ключи генерируются недостаточно рандомно
+        return SolanaKeyGeneratorManual.generateKeyPair();
+    }
+
+    /** Генерирует новeую пару ключей X25519 */
+    public static KeyPairBase58 generateNewKeyPairX25519()  throws Exception{  // todo это пока заглушка
+        return SolanaKeyGeneratorManual.generateKeyPair();
+    }
+
+    /** Проверяет статус транзакции по её подписи (signature) */
+    public static TxStatus getTransactionStatus(String signature) throws Exception {
+        return TransactionStatusHelper.getTxStatus(signature);
+    }
+
+    /**
+     * Обёртка для перевода SOL с одного аккаунта на другой.
+     *
+     * @param fromBase58Secret приватный ключ отправителя (в base58)
+     * @param toAddressBase58  публичный ключ получателя (в base58)
+     * @param lamports         сумма в лампортах (1 SOL = 1_000_000_000 лампортов)
+     */
+    public static String sendSol(String fromBase58Secret, String toAddressBase58, long lamports)  throws Exception{
+        return SolanaTransfer.sendSol(fromBase58Secret, toAddressBase58, lamports);
+    }
+
+    /** Выполняет регистрацию пользователя и одного устройства */
+    public static String registerUserWithOneDev(
+            String payerPubkeyB58,
+            String payerPrivkeyB58,
+            String login,
+            String deviceSignPubkeyB58,
+            String deviceX25519PubkeyB58
+    )  throws Exception {
+        return RegisterUserWithOneDev.callRegisterUserWithOneDev(
+                payerPubkeyB58,
+                payerPrivkeyB58,
+                login,
+                deviceSignPubkeyB58,
+                deviceX25519PubkeyB58
+        );
+    }
+
+    /** Получить объект UserByLogin по логину */
+    public static UserByLogin getUserByLogin(String login) throws Exception {
+        return UserByLoginReader.getUserByLogin(login);
+    }
+
+    /** Получить объект UserById по числовому ID */
+    public static UserById getUserById(long id) throws Exception {
+        return UserByIdReader.getUserById(id);
+    }
+
+
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/actions.md

@@ -0,0 +1,19 @@
+InitializeUserCounter - инициализирует счётчик пользователь (вызывается один раз)
+
+RegisterUserWithOneDev - регистрирует пользователя с одним устройством
+- оплачивает деньги
+- решистрирует акаунт (PDA) по ЛОГИНУ и (PDA) по id
+- регистрирует ключи пользователя и устройствва
+- увеличивает количество пользователей в ситеме ++1
+
+UserByLoginReader - читает данные пользователя по логину
+UserCounterReader - читает количество пользователей в системе
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -   
+SolanaKeyGeneratorManual - генерирует пары ключей
+ - - - - 
+SolanaBalanceChecker - показывает баланс акаунта
+SolanaAirdrop - запрашивает Airdrop
+SolanaTransfer - перевод со счёта на счёт
+-----------------------------------------
+Const - хранит константы настройки
+ResultChecker(sig) - проверяет результат транзакции

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/config/Const.java

@@ -0,0 +1,76 @@
+package me.shineup.solana.config;
+
+import me.shineup.solana.internal.utils.KeyPair;
+import org.p2p.solanaj.core.PublicKey;
+
+import java.text.DecimalFormat;
+
+
+
+public class Const {
+
+    /** Program ID из declare_id! */
+
+    public static final String PROGRAM_ID_str = "5dFcWDNp42Xn9Vv4oDMJzM4obBJ8hvDuAtPX54fT5L3t";      // shine
+
+    public static final String userSeedsPrefix = "u="; // префикс для Seed адреса пользователя по логину
+
+    public static String USER_COUNTER_SEED = "user_counter"; // Seed Адрес PDA счётчика пользователей
+
+    public static final PublicKey PROGRAM_ID_key = new PublicKey(PROGRAM_ID_str);//"BmCgGmQbSjkE6Zg8WAwhxDMNHiTknMYqTF4ZVMrPdTpz");      // shine
+
+
+
+    public static PublicKey ADMIN_FEE_ACCOUNT = new PublicKey("6bFc5Gz5qF172GQhK5HpDbWs8F6qcSxdHn5XqAstf1fY");
+
+
+    public static final String LOCAL_RPC_URL = "http://127.0.0.1:8899";
+    public static final String LOCAL_ANDROID_TEST_RPC_URL = "http://10.0.2.2:8899";
+    public static final String TESTNET_RPC_URL = "https://api.testnet.solana.com";
+    public static final String DEVNET_RPC_URL = "https://api.devnet.solana.com";
+
+    // RPC URL для используемой ноды Solana
+    public static String RPC_URL =  DEVNET_RPC_URL;
+    // Запись для хранения ключей
+//    public record KeyPair(String name, String publicKey, String privateKey) {}  не надо больше
+
+    // Массив пар ключей
+    public static final KeyPair[] KEYS = {
+            new KeyPair("key1", "HMww7YSVfwVm4i8sugqj7wyH26dqzHykzv3wzWwzEvPA", // есть в дев нет!!!  --url https://api.devnet.solana.com
+                    "5pbFo9Zq1VsNheHwbEp6AZKa6R62CZHoGkJFZnugpMEtCmkQFjuUP7TgA5hSPqv4NABGmPP62qVnDPHmRqEAwvJc"),
+            new KeyPair("key2", "E3ZDHbWv1qiFvDTmaRc9wjFCgbQw6UmKJLJYbaTNvjAh",
+                    "5qm1GJGXB1fFJ3YsU5Y3XXgTiQfaimqBWk79oEveFASH9D2of3jqUoT7dumBvS449fW5j5Sw8MgAMH2QBMmFPdry"),
+            new KeyPair("key3", "6bFc5Gz5qF172GQhK5HpDbWs8F6qcSxdHn5XqAstf1fY",
+                    "3VYfYZZ3ugmgwisiQQAfcimX9T65AE9BmwmYVixAUj4jyneccSE9rzbC3g5twvH7ECZ8xgp7emJo3pR4yQqCwjGn")
+    };
+
+    // Метод для определения ключа
+    public static String identifyKey(String key) {
+        for (KeyPair kp : KEYS) {
+            if (kp.getPublicKey().equals(key)) {
+                return kp.getName() + "(public)";
+            }
+            if (kp.getPrivateKey().equals(key)) {
+                return kp.getName() + "(private)";
+            }
+        }
+        return key; // если не найдено
+    }
+
+    // Метод для получения KeyPair по имени
+    public static KeyPair getKeyByName(String name) {
+        for (KeyPair kp : KEYS) {
+            if (kp.getName().equals(name)) {
+                return kp;
+            }
+        }
+        return null; // если не найдено
+    }
+
+    // Метод форматирования лампортов в SOL
+    public static String lamportsToSol(long lamports) {
+        double sol = lamports / 1_000_000_000.0;
+        DecimalFormat df = new DecimalFormat("0.00000000");
+        return df.format(sol);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/ExeptionList.txt

@@ -0,0 +1,35 @@
+
+Exeption - если что то полетело в коде
+
+SolanaRpcConnectionException -  Не удалось подключиться к RPC Solana или получить ответ
+
+SolanaLibLogicException - Базовое исключение всех ошибок, связанных с Solana
+   Выкидываем во всех не стандартных случаях из библиотеки вместо стандартного   Exception
+
+SolanaProgramException  -  Исключение, выбрасываемое при кастомной ошибке от Solana-программы (смарт контракта).        Например: "custom program error: 0x1771"
+
+SolanaInsufficientFundsForFeeException  -  Недостаточно SOL для оплаты комиссии (InsufficientFundsForFee).
+   это если вызвали регистрацию без средств
+   (но получается тоже не надо так как - прога не вызовет её без проверки баланса)
+
+
+
+
+нет такого пользователя
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+   SolanaIncorrectProgramIdException  Неверный programId — вызывается не та программа (IncorrectProgramId)
+возможно надо что бы быстро находить новый програм Ид
+(но по факту он не меняется если кто то не потеряет пароль!!!  ) ну или потребуется один раз при переходе на DAO

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaErrorHandler.java

@@ -0,0 +1,43 @@
+package me.shineup.solana.exceptions;
+
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+public class SolanaErrorHandler {
+
+    public static void handleRpcJsonError(String json) throws SolanaException {
+        try {
+            JsonObject obj = JsonParser.parseString(json).getAsJsonObject();
+            if (!obj.has("error")) return;
+
+            JsonObject error = obj.getAsJsonObject("error");
+            String msg = error.has("message") ? error.get("message").getAsString() : "";
+
+            handleSolanaError(msg);
+
+        } catch (Exception e) {
+            // fallback
+            throw new SolanaException("Ошибка обработки RPC-ошибки", e);
+        }
+    }
+
+    public static void handleSolanaError(String errorMessage) throws SolanaException {
+        if (errorMessage == null || errorMessage.isEmpty()) return;
+
+        if (errorMessage.contains("custom program error: 0x")) {
+            String hex = errorMessage.substring(errorMessage.indexOf("0x")).split(" ")[0];
+            throw new SolanaException_InProgram(hex);
+        }
+
+        if (errorMessage.contains("InsufficientFundsForFee")) {
+            throw new SolanaException_InsufficientFundsForFee();
+        }
+
+        if (errorMessage.contains("IncorrectProgramId")) {
+            throw new SolanaException_IncorrectProgramId();
+        }
+
+        throw new SolanaException("Неизвестная ошибка Solana: " + errorMessage);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException.java

@@ -0,0 +1,13 @@
+package me.shineup.solana.exceptions;
+
+
+/** Базовое исключение всех ошибок, связанных с Solana */
+public class SolanaException extends Exception {
+    public SolanaException(String message) {
+        super(message);
+    }
+
+    public SolanaException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_InProgram.java

@@ -0,0 +1,41 @@
+package me.shineup.solana.exceptions;
+
+/**
+ * Исключение, выбрасываемое при кастомной ошибке от Solana-программы.
+ * Например: "custom program error: 0x1771" или 10001
+ */
+public class SolanaException_InProgram extends SolanaException {
+    private final int errorCode;
+
+    /**
+     * Создаёт исключение на основе шестнадцатеричного кода (например, "0x1771").
+     */
+    public SolanaException_InProgram(String errorCodeHex) {
+        super("Ошибка от смарт-контракта. Код: " + parseHex(errorCodeHex));
+        this.errorCode = parseHex(errorCodeHex);
+    }
+
+    /**
+     * Создаёт исключение на основе десятичного кода (например, 10001).
+     */
+    public SolanaException_InProgram(int errorCodeDecimal) {
+        super("Ошибка от смарт-контракта. Код: " + errorCodeDecimal);
+        this.errorCode = errorCodeDecimal;
+    }
+
+    public int getErrorCodeDecimal() {
+        return errorCode;
+    }
+
+    public String getErrorCodeHex() {
+        return "0x" + Integer.toHexString(errorCode);
+    }
+
+    private static int parseHex(String hex) {
+        try {
+            return Integer.parseInt(hex.replace("0x", ""), 16);
+        } catch (NumberFormatException e) {
+            return -1;
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_IncorrectProgramId.java

@@ -0,0 +1,12 @@
+package me.shineup.solana.exceptions;
+
+/**
+ * Неверный programId — вызывается не та программа (IncorrectProgramId).
+ */
+public class SolanaException_IncorrectProgramId extends SolanaException {
+    public SolanaException_IncorrectProgramId() {
+        super("Указан неверный programId — не соответствует контракту");
+    }
+}
+
+

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_InsufficientFundsForFee.java

@@ -0,0 +1,10 @@
+package me.shineup.solana.exceptions;
+
+/**
+ * Недостаточно SOL для оплаты комиссии (InsufficientFundsForFee).
+ */
+public class SolanaException_InsufficientFundsForFee extends SolanaException {
+    public SolanaException_InsufficientFundsForFee() {
+        super("Недостаточно средств на балансе для оплаты комиссии (InsufficientFundsForFee)");
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_LibLogic.java

@@ -0,0 +1,21 @@
+package me.shineup.solana.exceptions;
+
+/**
+ * Исключение, выбрасываемое вручную при логических проверках в библиотеке.
+ * К сообщению автоматически добавляется строка вызова (класс и номер строки).
+ */
+public class SolanaException_LibLogic extends SolanaException {
+
+    public SolanaException_LibLogic(String userMessage) {
+        super(userMessage + getSourceSuffix());
+    }
+
+    private static String getSourceSuffix() {
+        StackTraceElement[] stack = Thread.currentThread().getStackTrace();
+        if (stack.length > 3) {
+            StackTraceElement caller = stack[3];
+            return " (исходный код: " + caller.getFileName() + ":" + caller.getLineNumber() + ")";
+        }
+        return "";
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_RpcConnection.java

@@ -0,0 +1,8 @@
+package me.shineup.solana.exceptions;
+
+/** Не удалось подключиться к RPC или получить ответ */
+public class SolanaException_RpcConnection extends SolanaException {
+    public SolanaException_RpcConnection(String message) {
+        super(message);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_UserNotFound.java

@@ -0,0 +1,14 @@
+package me.shineup.solana.exceptions;
+
+/**
+ * Пользователь с указанным идентификатором не найден в системе.
+ */
+public class SolanaException_UserNotFound extends SolanaException {
+    public SolanaException_UserNotFound() {
+        super("Пользователь не найден в системе.");
+    }
+
+    public SolanaException_UserNotFound(String msg) {
+        super("Пользователь не найден в системе: " + msg);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/InitializeUserCounter/InitializeUserCounter.java

@@ -0,0 +1,98 @@
+package me.shineup.solana.internal.callSolanaFunc.InitializeUserCounter;
+
+
+import org.p2p.solanaj.core.AccountMeta;
+import org.p2p.solanaj.core.PublicKey;
+import org.p2p.solanaj.programs.SystemProgram;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.internal.utils.resultChecker.ResultChecker;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.SolanaProgramCaller;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Вызывает Anchor-функцию `initialize_user_counter` смарт-контракта на Solana.
+ *
+ * Эта функция предназначена для одноразовой инициализации PDA-аккаунта, в котором будет храниться
+ * счётчик пользователей. Аккаунт создаётся с сидом "user_counter" и содержит 8 байт, представляющих число.
+ *
+ * Повторный вызов приведёт к ошибке (если PDA уже существует).
+ *
+ */
+
+public class InitializeUserCounter {
+
+    private static final Logger LOG = LoggerFactory.getLogger(InitializeUserCounter.class);
+
+/**
+ * Вызывает Anchor-функцию `initialize_user_counter` смарт-контракта на Solana.
+ *
+ * Эта функция предназначена для одноразовой инициализации PDA-аккаунта, в котором будет храниться
+ * счётчик пользователей. Аккаунт создаётся с сидом "user_counter" и содержит 8 байт, представляющих число.
+ * Вызвать её в принципе может кто угодно, кто оплатит создание этого пда
+ *
+ * После того как PDA будет создан, любой повторный вызов приведёт к ошибке (если PDA уже существует).
+ */
+     public static String callInitializeUserCounter(
+            String publicKeyB58,
+            String privateKeyB58
+    ) {
+        try {
+            // ─────────────────────────────────────────────────────────────
+            // 1. Генерируем PDA-адрес для сидов ["user_counter"]
+            // ─────────────────────────────────────────────────────────────
+            String seed = "user_counter";
+            PublicKey counterPda = PublicKey.findProgramAddress(
+                    Collections.singletonList(seed.getBytes(StandardCharsets.UTF_8)),
+                    Const.PROGRAM_ID_key
+            ).getAddress();
+
+            // ─────────────────────────────────────────────────────────────
+            // 2. Аргументы Anchor-функции: initialize_user_counter не требует входных данных
+            // ─────────────────────────────────────────────────────────────
+            byte[] serializedArgs = new byte[0];  // нет параметров
+
+            // ─────────────────────────────────────────────────────────────
+            // 3. Список аккаунтов
+            // ─────────────────────────────────────────────────────────────
+            List<AccountMeta> accounts = Arrays.asList(
+                    new AccountMeta(new PublicKey(publicKeyB58), true, true),       // payer / signer
+                    new AccountMeta(counterPda, false, true),                      // pda: user_counter
+                    new AccountMeta(SystemProgram.PROGRAM_ID, false, false)        // system_program
+            );
+
+            // ─────────────────────────────────────────────────────────────
+            // 4. Вызов Anchor-функции
+            // ─────────────────────────────────────────────────────────────
+            return SolanaProgramCaller.callAnchorFunction(
+                    publicKeyB58,
+                    privateKeyB58,
+                    "initialize_user_counter",  // имя функции Anchor
+                    Const.PROGRAM_ID_key,
+                    accounts,
+                    serializedArgs
+            );
+
+        } catch (Exception e) {
+            LOG.error("❌ Ошибка вызова initialize_user_counter", e);
+            return null;
+        }
+    }
+
+
+    // Для теста
+    public static void main(String[] args) {
+//         Const.RPC_URL=Const.DEVNET_RPC_URL;
+        String sig = InitializeUserCounter.callInitializeUserCounter(
+                Const.getKeyByName("key1").getPublicKey(),
+                Const.getKeyByName("key1").getPrivateKey()
+        );
+        ResultChecker.check(sig);
+    }
+}
+

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/RegisterUser/RegisterUserStepOne.java

@@ -0,0 +1,104 @@
+package me.shineup.solana.internal.callSolanaFunc.RegisterUser;
+
+import org.p2p.solanaj.core.AccountMeta;
+import org.p2p.solanaj.core.PublicKey;
+import org.p2p.solanaj.programs.SystemProgram;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.internal.utils.resultChecker.ResultChecker;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.SolanaProgramCaller;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Вызывает Anchor-функцию `register_user_step_one`.       !!!!!!!!! ЭТО УСТАРЕЛО И БОЛЬШЕ НЕ НАДО
+ *
+ * Функция создаёт нового пользователя:
+ * - проверяет логин,
+ * - создаёт PDA-аккаунт пользователя,
+ * - переводит 0.01 SOL на счёт администрации,
+ * - сохраняет логин, ID, pubkey и статус 0 в PDA,
+ * - обновляет счётчик пользователей.
+ */
+
+
+public class RegisterUserStepOne {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RegisterUserStepOne.class);
+
+    public static String callRegisterUserStepOne(
+            String payerPubkeyB58,
+            String payerPrivkeyB58,
+            String login,
+            String userPubkeyB58
+    ) {
+        try {
+            // 1. Адрес получателя комиссии
+            PublicKey feeReceiver = Const.ADMIN_FEE_ACCOUNT;
+
+            // 2. PDA-адрес по логину: seed = "u=" + login
+            String seed = Const.userSeedsPrefix + login;
+            PublicKey userPda = PublicKey.findProgramAddress(
+                    Collections.singletonList(seed.getBytes(StandardCharsets.UTF_8)),
+                    Const.PROGRAM_ID_key
+            ).getAddress();
+
+            // 3. Адрес PDA счётчика пользователей
+            String counterSeed = Const.USER_COUNTER_SEED;
+            PublicKey counterPda = PublicKey.findProgramAddress(
+                    Collections.singletonList(counterSeed.getBytes(StandardCharsets.UTF_8)),
+                    Const.PROGRAM_ID_key
+            ).getAddress();
+
+            // 4. Сериализация аргументов Anchor
+            byte[] loginBytes = login.getBytes(StandardCharsets.UTF_8);
+            byte[] userPubkeyBytes = new PublicKey(userPubkeyB58).toByteArray();
+
+            byte[] serializedArgs = SolanaProgramCaller.encodeAnchorArgs(
+                    Arrays.asList("string", "pubkey"),
+                    Arrays.asList(loginBytes, userPubkeyBytes)
+            );
+
+            // 5. Аккаунты, требуемые для вызова
+            List<AccountMeta> accounts = Arrays.asList(
+                    new AccountMeta(new PublicKey(payerPubkeyB58), true, true), // signer
+                    new AccountMeta(counterPda, false, true),                   // user_counter
+                    new AccountMeta(userPda, false, true),                      // user_by_login_pda
+                    new AccountMeta(SystemProgram.PROGRAM_ID, false, false),    // system_program
+                    new AccountMeta(feeReceiver, false, true)                   // fee_receiver
+            );
+
+            // 6. Вызов Anchor-функции
+            return SolanaProgramCaller.callAnchorFunction(
+                    payerPubkeyB58,
+                    payerPrivkeyB58,
+                    "register_user_step_one",
+                    Const.PROGRAM_ID_key,
+                    accounts,
+                    serializedArgs
+            );
+
+        } catch (Exception e) {
+            LOG.error("❌ Ошибка вызова register_user_step_one", e);
+            return null;
+        }
+    }
+
+    // Для теста
+    public static void main(String[] args) {
+        Const.RPC_URL = Const.LOCAL_RPC_URL;
+
+        String sig = RegisterUserStepOne.callRegisterUserStepOne(
+                Const.getKeyByName("key1").getPublicKey(),    // кто платит
+                Const.getKeyByName("key1").getPrivateKey(),   //
+                "testlogin",                    // логин пользователя
+                Const.getKeyByName("key2").getPublicKey() // публичный ключ пользователя
+        );
+        ResultChecker.check(sig);
+    }
+
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/RegisterUser/RegisterUserWithOneDev.java

@@ -0,0 +1,156 @@
+package me.shineup.solana.internal.callSolanaFunc.RegisterUser;
+
+import me.shineup.solana.SolanaWrapper;
+import me.shineup.solana.internal.readFromSolana.userCounter.UserCounterReader;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.standartActions.keysGenerator.KeyPairBase58;
+import me.shineup.solana.internal.utils.SolanaProgramCaller;
+import me.shineup.solana.internal.utils.resultChecker.ResultChecker;
+import org.p2p.solanaj.core.AccountMeta;
+import org.p2p.solanaj.core.PublicKey;
+import org.p2p.solanaj.programs.SystemProgram;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static me.shineup.solana.internal.standartActions.keysGenerator.SolanaKeyGeneratorManual.generateKeyPair;
+
+/**
+ * Вызывает Anchor-функцию `register_user_with_one_dev`.
+ *
+ * Выполняет регистрацию пользователя и одного устройства.
+ */
+public class RegisterUserWithOneDev {
+
+    private static final Logger LOG = LoggerFactory.getLogger(RegisterUserWithOneDev.class);
+
+    // Пример вызова
+    public static void main(String[] args) {
+//        Const.RPC_URL = Const.LOCAL_RPC_URL;
+        Const.RPC_URL=Const.DEVNET_RPC_URL;
+        try {
+            String publicKey = "2fppzT84GoDqQe2RCxuK2gjZUrMhkzKgVTY6BzfLF9RX";
+            String privateKey = "2qTERJQ2EBPsHWNXxhAWW4pBk1beo1BWtifCPsDbrDhw9z5riNLsUUj6BNQ9UbprJq398Zk3Fv21ZGUjRrAU4T73";
+            SolanaWrapper.getBalance(Const.getKeyByName("key1").publicKey);
+//            SolanaWrapper.sendSol(Const.getKeyByName("key1").getPrivateKey(),publicKey, 1000000);
+            SolanaWrapper.getBalance(publicKey);
+//            KeyPairBase58 keys = generateKeyPair();
+            String sig = RegisterUserWithOneDev.callRegisterUserWithOneDev(
+                    Const.getKeyByName("key1").getPublicKey(),     // payer
+                    Const.getKeyByName("key1").getPrivateKey(),    //
+                    "testlogin",                                   // логин
+                    Const.getKeyByName("key2").getPublicKey(),     // подпись устройства
+                    Const.getKeyByName("key2").getPublicKey()      // x25519
+            );
+            ResultChecker.check(sig);
+        } catch (Exception e) {
+            LOG.error(e.getMessage());
+        }
+
+
+    }
+
+
+    public static String callRegisterUserWithOneDev(
+            String payerPubkeyB58,
+            String payerPrivkeyB58,
+            String login,
+//            String userPubkeyB58,   пока userPubkeyB58=payerPubkeyB58
+            String deviceSignPubkeyB58,
+            String deviceX25519PubkeyB58
+    ) throws Exception {
+
+            // Адреса
+            PublicKey payer = new PublicKey(payerPubkeyB58);
+/**            PublicKey userPub = new PublicKey(userPubkeyB58);
+ * тут в принципе можно передавать на смарт контракт разные параметры
+ * и получиться что платит один а создаёт аккаунт на другое имя
+ * это может актуально при расширении, если дописать додумать и т.д.
+ *          но пока это отключено и кто оплатил тна того и оформляем аккаунт
+ *          пока так работает только за себя и можно отпраавлять транзакции
+ */
+            PublicKey userPub = new PublicKey(payerPubkeyB58);  // пока тот кто подписал транзакцию, на него же и аккаунт создаём
+
+
+            PublicKey devSignPub = new PublicKey(deviceSignPubkeyB58);
+            PublicKey devX25519Pub = new PublicKey(deviceX25519PubkeyB58);
+
+            // Читаем текущий ID
+            long currentId = UserCounterReader.getUserCount();
+            long newId = currentId + 1;
+
+            // Счётчик пользователей
+
+            PublicKey counterPda = PublicKey.findProgramAddress(
+                    Arrays.asList("user_counter".getBytes(StandardCharsets.UTF_8)),
+                    Const.PROGRAM_ID_key
+            ).getAddress();
+
+            // PDA по логину: ["login=", login]
+            PublicKey loginPda = PublicKey.findProgramAddress(
+                    Arrays.asList(
+                            "login=".getBytes(StandardCharsets.UTF_8),
+                            login.getBytes(StandardCharsets.UTF_8)
+                    ),
+                    Const.PROGRAM_ID_key
+            ).getAddress();
+
+            // 5 возможных PDA по ID: ["userId=", String.valueOf(newId)]
+            String idSeedStr = String.valueOf(newId);
+            List<PublicKey> idCandidates = new ArrayList<>();
+            for (int i = 0; i < 5; i++) {
+                byte[] prefix = "userId=".getBytes(StandardCharsets.UTF_8);
+                byte[] id = idSeedStr.getBytes(StandardCharsets.UTF_8);
+                byte[] seed1 = prefix;
+                byte[] seed2 = id;
+                PublicKey pda = PublicKey.findProgramAddress(Arrays.asList(seed1, seed2), Const.PROGRAM_ID_key).getAddress();
+                idCandidates.add(pda);
+            }
+
+            // Комиссионный адрес
+            PublicKey feeReceiver = Const.ADMIN_FEE_ACCOUNT;
+
+            // Аргументы Anchor
+            byte[] loginBytes = login.getBytes(StandardCharsets.UTF_8);
+            byte[] pubkeyBytes = userPub.toByteArray();
+            byte[] devSignBytes = devSignPub.toByteArray();
+            byte[] devX25519Bytes = devX25519Pub.toByteArray();
+
+            byte[] serializedArgs = SolanaProgramCaller.encodeAnchorArgs(
+                    Arrays.asList("string", "pubkey", "pubkey", "pubkey"),
+                    Arrays.asList(loginBytes, pubkeyBytes, devSignBytes, devX25519Bytes)
+            );
+
+            // Список аккаунтов
+            List<AccountMeta> accounts = new ArrayList<AccountMeta>();
+            accounts.add(new AccountMeta(payer, true, true));
+            accounts.add(new AccountMeta(counterPda, false, true));
+            accounts.add(new AccountMeta(loginPda, false, true));
+
+            for (PublicKey idPda : idCandidates) {
+                accounts.add(new AccountMeta(idPda, false, true));
+            }
+
+            accounts.add(new AccountMeta(SystemProgram.PROGRAM_ID, false, false));
+            accounts.add(new AccountMeta(feeReceiver, false, true));
+
+            // Вызов Anchor-функции
+            return SolanaProgramCaller.callAnchorFunction(
+                    payerPubkeyB58,
+                    payerPrivkeyB58,
+                    "register_user_with_one_dev",
+                    Const.PROGRAM_ID_key,
+                    accounts,
+                    serializedArgs
+            );
+
+    }
+
+}
+
+
+

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userById/UserByIdParser.java

@@ -0,0 +1,103 @@
+package me.shineup.solana.internal.readFromSolana.userById;
+
+import me.shineup.solana.exceptions.SolanaException;
+import me.shineup.solana.model.UserById;
+import org.bitcoinj.core.Base58;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Десериализует сырые байты из PDA в объект {@link UserById}.
+ *
+ * Сейчас поддерживается только формат 1, но общий метод
+ * parse(...) готов к расширению версий.
+ */
+class UserByIdParser {
+
+    /** Точка входа: определяем формат по первым 4 байтам (LE u32). */
+    public static UserById parse(byte[] data) throws Exception {
+        if (data.length < 4)
+            throw new SolanaException("Недостаточно данных для чтения format_type");
+
+        int fmt = ByteBuffer.wrap(data, 0, 4)
+                .order(ByteOrder.LITTLE_ENDIAN)
+                .getInt();
+
+        switch (fmt) {
+            case 1:
+                return parseFormat1(data);
+            default:
+                throw new SolanaException("Неподдерживаемый формат: " + fmt);
+        }
+    }
+
+    /**
+     * Формат 1 (см. Rust-комментарии):
+     * [0..4]   format
+     * [4..12]  id (u64 LE)
+     * [12]     len(login) u8
+     * [13..]   login
+     * [...]    pubkey 32 байта
+     * [...]    deviceCount u8
+     * [...]    devices ×65 байт (type + 32 + 32)
+     */
+    private static UserById parseFormat1(byte[] data) throws Exception {
+        int offset = 4;
+
+        // id
+        if (data.length < offset + 8) throw new Exception("Мало байт для id");
+        long id = ByteBuffer.wrap(data, offset, 8)
+                .order(ByteOrder.LITTLE_ENDIAN).getLong();
+        offset += 8;
+
+        // login
+        int loginLen = data[offset] & 0xFF;
+        offset += 1;
+        if (data.length < offset + loginLen) throw new Exception("Мало байт для login");
+        String login = new String(data, offset, loginLen, StandardCharsets.UTF_8);
+        offset += loginLen;
+
+        // pubkey
+        if (data.length < offset + 32) throw new Exception("Мало байт для pubkey");
+        byte[] pubkeyBytes = new byte[32];
+        System.arraycopy(data, offset, pubkeyBytes, 0, 32);
+        String pubkey58 = Base58.encode(pubkeyBytes);
+        offset += 32;
+
+        // deviceCount
+        if (data.length < offset + 1) throw new Exception("Мало байт для deviceCount");
+        int devCount = data[offset] & 0xFF;
+        offset += 1;
+
+        // devices
+        List<UserById.DeviceInfo> devices = new ArrayList<>();
+        for (int i = 0; i < devCount; i++) {
+            if (data.length < offset + 65)
+                throw new Exception("Мало байт для devices[" + i + "]");
+            UserById.DeviceInfo d = new UserById.DeviceInfo();
+            d.deviceType = data[offset] & 0xFF;
+            byte[] devPub = new byte[32];
+            byte[] x25519 = new byte[32];
+            System.arraycopy(data, offset + 1,  devPub, 0, 32);
+            System.arraycopy(data, offset + 33, x25519, 0, 32);
+            d.devicePubkey  = Base58.encode(devPub);
+            d.x25519Pubkey  = Base58.encode(x25519);
+            devices.add(d);
+            offset += 65;
+        }
+
+        // собираем объект
+        UserById u = new UserById();
+        u.format       = 1;
+        u.id           = id;
+        u.login        = login;
+        u.pubkey       = pubkey58;
+        u.deviceCount  = devCount;
+        u.devices      = devices;
+        return u;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userById/UserByIdReader.java

@@ -0,0 +1,48 @@
+package me.shineup.solana.internal.readFromSolana.userById;
+
+import me.shineup.solana.exceptions.SolanaException_UserNotFound;
+import me.shineup.solana.model.UserById;
+import me.shineup.solana.internal.utils.reader.PdaReader;
+import me.shineup.solana.config.Const;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Читает из PDA данные пользователя по числовому ID
+ * и десериализует их в {@link UserById}.
+ */
+public class UserByIdReader {
+
+    private static final Logger LOG = LoggerFactory.getLogger(UserByIdReader.class);
+
+    /** Получить UserById по ID. */
+    public static UserById getUserById(long id) throws Exception{
+        byte[] seed1 = "userId=".getBytes(StandardCharsets.UTF_8);
+        byte[] seed2 = Long.toString(id).getBytes(StandardCharsets.UTF_8);
+        String programId = Const.PROGRAM_ID_str;
+
+        byte[] data = PdaReader.readTwoSeeds(seed1, seed2, programId);
+
+        if (data == null) {
+            LOG.warn("⚠️ Нет данных в PDA для id={}", id);
+            throw new SolanaException_UserNotFound();
+        }
+
+        return UserByIdParser.parse(data);         // Передаём данные в парсер
+    }
+
+    /** Быстрый тест чтения. */
+    public static void main(String[] args) {
+        long id = 10; // поменять на существующий ID
+        try {
+            UserById u = UserByIdReader.getUserById(id);
+            System.out.println("✅ Найден: " + u);
+        } catch (SolanaException_UserNotFound e) {
+            System.out.println("⚠️ Пользователь с id=" + id + " не найден");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userByLogin/UserByLoginParser.java

@@ -0,0 +1,73 @@
+package me.shineup.solana.internal.readFromSolana.userByLogin;
+
+
+import me.shineup.solana.model.UserByLogin;
+
+/**
+ * Парсер для десериализации массива байт в объект UserByLogin.
+ * Поддерживает несколько форматов, определяемых по первым 4 байтам (LE u32).
+ */
+class UserByLoginParser {
+
+    /**
+     * Основной метод: определяет формат по первым 4 байтам, вызывает нужный парсер.
+     * @param data байты, полученные из PDA
+     * @return объект UserByLogin
+     * @throws Exception если формат неизвестен или ошибка разбора
+     */
+    public static UserByLogin parse(byte[] data) throws Exception {
+        if (data.length < 4) throw new Exception("Недостаточно данных для чтения format_type");
+
+        int format = java.nio.ByteBuffer.wrap(data, 0, 4)
+                .order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt();
+
+        switch (format) {
+            case 1:
+                return parseFormat1(data);
+            default:
+                throw new Exception("Неподдерживаемый формат данных: " + format);
+        }
+    }
+
+    /**
+     * Парсит формат 1:
+     * [0..4]    — формат
+     * [4]       — длина логина (u8)
+     * [5..X]    — логин
+     * [X..X+8]  — id (u64 LE)
+     * [X..X+32] — pubkey (32 байта)
+     * [X+32..X+36] — status (u32 LE)
+     */
+    public static UserByLogin parseFormat1(byte[] data) throws Exception {
+        int offset = 4; // после format_type
+
+        int loginLen = data[offset] & 0xFF;
+        offset += 1;
+
+        if (data.length < offset + loginLen + 8 + 32 + 4)
+            throw new Exception("Недостаточно байт для парсинга format 1");
+
+        String login = new String(data, offset, loginLen, java.nio.charset.StandardCharsets.UTF_8);
+        offset += loginLen;
+
+        long id = java.nio.ByteBuffer.wrap(data, offset, 8)
+                .order(java.nio.ByteOrder.LITTLE_ENDIAN).getLong();
+        offset += 8;
+
+        byte[] pubkeyBytes = new byte[32];
+        System.arraycopy(data, offset, pubkeyBytes, 0, 32);
+        String pubkey = org.bitcoinj.core.Base58.encode(pubkeyBytes);
+        offset += 32;
+
+        int status = java.nio.ByteBuffer.wrap(data, offset, 4)
+                .order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt();
+
+        UserByLogin result = new UserByLogin();
+        result.format = 1;
+        result.login = login;
+        result.id = id;
+        result.pubkey = pubkey;
+        result.status = status;
+        return result;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userByLogin/UserByLoginReader.java

@@ -0,0 +1,58 @@
+package me.shineup.solana.internal.readFromSolana.userByLogin;
+
+
+import me.shineup.solana.exceptions.SolanaException_UserNotFound;
+import me.shineup.solana.model.UserByLogin;
+import me.shineup.solana.internal.utils.reader.PdaReader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Класс для получения объекта UserByLogin по логину из PDA
+ */
+public class UserByLoginReader {
+
+    private static final Logger LOG = LoggerFactory.getLogger(UserByLoginReader.class);
+
+    /**
+     * Получает объект UserByLogin по логину
+     * @param login Логин пользователя (например, "sol_user")
+     * @return Объект UserByLogin или null, если данных нет
+     * @throws Exception если ошибка соединения или парсинга
+     */
+    public static UserByLogin getUserByLogin(String login) throws Exception {
+        byte[] seed1 = "login=".getBytes(StandardCharsets.UTF_8);
+        byte[] seed2 = login.getBytes(StandardCharsets.UTF_8);
+        String programId = Const.PROGRAM_ID_str;
+
+        byte[] data = PdaReader.readTwoSeeds(seed1, seed2, programId);
+
+        if (data == null) {
+            LOG.warn("⚠️ Нет данных в PDA для логина '{}'", login);
+            throw new SolanaException_UserNotFound();
+        }
+
+        // Передаём данные в парсер
+        return UserByLoginParser.parse(data);
+    }
+
+    /**
+     * Тестовый запуск чтения информации о пользователе
+     */
+    public static void main(String[] args) {
+        String login = "testlogin3"; // замените на нужный логин
+        try {
+            UserByLogin user = UserByLoginReader.getUserByLogin(login);
+            System.out.println("✅ Найден пользователь: " + login);
+        } catch (SolanaException_UserNotFound e) {
+            System.out.println("⚠️ Пользователь с id=" + login + " не найден");
+        } catch (Exception e) {
+            System.err.println("❌ Ошибка при получении информации о пользователе: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}
+

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userCounter/UserCounterReader.java

@@ -0,0 +1,60 @@
+package me.shineup.solana.internal.readFromSolana.userCounter;
+
+
+
+import me.shineup.solana.exceptions.SolanaException;
+import me.shineup.solana.internal.utils.reader.PdaReader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Утилита для получения значения счётчика пользователей из PDA.
+ */
+public class UserCounterReader {
+
+    private static final Logger LOG = LoggerFactory.getLogger(UserCounterReader.class);
+
+    /**
+     * Считывает текущее количество пользователей из PDA "user_counter".
+     *
+     * @return количество пользователей (long), либо -1 если нет данных
+     * @throws Exception при ошибке подключения или чтения
+     */
+    public static long getUserCount() throws Exception {
+        String seed = "user_counter";
+        String programId = Const.PROGRAM_ID_str;
+
+        byte[] data = PdaReader.readOneSeed(seed, programId);
+        if (data == null || data.length < 8) {
+            throw new SolanaException("⚠️ Не удалось прочитать счётчик пользователей — PDA пуст или слишком короткий"); // этого не должно случаться
+        }
+
+        // Считываем первые 8 байт как u64 (Little Endian)
+        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
+        long count = buffer.getLong();
+
+        LOG.debug("👥 На данный момент в системе зарегистрировано: {} пользователей", count);
+        return count;
+    }
+
+    /**
+     * Тестовый запуск
+     */
+    public static void main(String[] args) {
+        try {
+            long count = getUserCount();
+            if (count >= 0) {
+                System.out.println("✅  👥  Количество пользователей системы на данный момент: " + count);
+            } else {
+                System.out.println("⚠️ Счётчик не найден или пуст");
+            }
+        } catch (Exception e) {
+            System.err.println("❌ Ошибка при чтении счётчика пользователей: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/airDrops/SolanaAirdrop.java

@@ -0,0 +1,68 @@
+package me.shineup.solana.internal.standartActions.airDrops;
+
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import me.shineup.solana.exceptions.SolanaException_LibLogic;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.SolanaRpcClient;
+
+
+public class SolanaAirdrop {
+    private static final Logger log = LoggerFactory.getLogger(SolanaAirdrop.class);
+
+
+    //
+    public static void main(String[] args) {
+
+        // Кол-во лампортов (1 SOL = 1_000_000_000 лампортов)
+        long lamports = 1_000_000_000L;
+        try {
+
+            // Вызываем airdrop
+            String trx = SolanaAirdrop.requestAirdrop(Const.getKeyByName("key1").getPublicKey(), lamports);
+
+
+            // Вывод результата
+            log.info("Баланс должен скоро обновиться. " + trx);
+        } catch (Exception e) {
+            log.error("Airdrop не удался." + e.getMessage());
+        }
+    }
+
+    /** запрашивает AirDrop на счёт  */
+    public static String requestAirdrop(String publicKey, long lamports) throws Exception{
+//        String requestJson = """
+//            {
+//              "jsonrpc": "2.0",
+//              "id": 1,
+//              "method": "requestAirdrop",
+//              "params": ["%s", %d]
+//            }
+//            """.formatted(publicKey, lamports);
+
+        String requestJson = String.format(
+                "{\n" +
+                        "  \"jsonrpc\": \"2.0\",\n" +
+                        "  \"id\": 1,\n" +
+                        "  \"method\": \"requestAirdrop\",\n" +
+                        "  \"params\": [\"%s\", %d]\n" +
+                        "}", publicKey, lamports);
+
+
+            String response = SolanaRpcClient.getInstance().sendRequest(requestJson);
+
+            JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+
+            if (json.has("result")) {
+                String txSignature = json.get("result").getAsString();
+                log.info("✅ Airdrop успешно запрошен. Tx: " + txSignature);
+                return txSignature;
+            }
+            throw new SolanaException_LibLogic("Неизвестный ответ: " + response);
+    }
+
+
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/balanse/SolanaBalanceChecker.java

@@ -0,0 +1,72 @@
+package me.shineup.solana.internal.standartActions.balanse;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.SolanaRpcClient;
+
+public class SolanaBalanceChecker {
+
+    // для теста
+    public static void main(String[] args) {
+        try {
+
+//        Const.RPC_URL = Const.LOCAL_RPC_URL;
+            Const.RPC_URL = "https://api.devnet.solana.com";
+            //Long balance1 = SolanaBalanceChecker.getBalance(Const.getKeyByName("key1").getPublicKey());
+            Long balance1 = SolanaBalanceChecker.getBalance("HMww7YSVfwVm4i8sugqj7wyH26dqzHykzv3wzWwzEvPA");
+            Long balance2 = SolanaBalanceChecker.getBalance(Const.getKeyByName("key2").getPublicKey());
+            Long balance3 = SolanaBalanceChecker.getBalance(Const.getKeyByName("key3").getPublicKey());
+        } catch (Exception e) {
+            log.error( e.getMessage());
+        }
+    }
+
+    private static final Logger log = LoggerFactory.getLogger(SolanaBalanceChecker.class);
+    private final Gson gson = new Gson();
+
+    /** показывает баланс счёта */
+    public static long getBalance(String publicKey) throws Exception {
+
+        String requestJson = String.format(
+                "{\n" +
+                        "  \"jsonrpc\": \"2.0\",\n" +
+                        "  \"id\": 1,\n" +
+                        "  \"method\": \"getBalance\",\n" +
+                        "  \"params\": [\"%s\"]\n" +
+                        "}", publicKey);
+//        try {
+            String responseJson = SolanaRpcClient.getInstance().sendRequest(requestJson);
+
+            // Парсим строку JSON в дерево объектов
+            JsonObject root = JsonParser.parseString(responseJson).getAsJsonObject();
+
+//            if (root.has("error")) {
+//                log.error("❌ Не удалось получить баланс для " + publicKey);
+//                log.error("Ошибка от RPC: " + root.get("error"));
+//                new SolanaLibLogicException() ;
+//            }
+
+            log.debug("📥 Ответ от RPC: " + responseJson);
+
+            long balance = root.getAsJsonObject("result").get("value").getAsLong();
+            double sol = balance / 1_000_000_000.0;
+
+            log.info("✅ Баланс кошелька " + Const.identifyKey(publicKey) + ": " + Const.lamportsToSol(balance));// + " SOL или лампортов " + balance );
+
+            return balance;
+
+//        } catch (Exception e) {
+//            log.error("❌ Не удалось получить баланс для " + publicKey);
+//            log.error("Ошибка при получении баланса: " + e.getMessage());
+//            log.error("Ошибка при получении баланса: " + e.getStackTrace()[0] );
+//            log.error("Ошибка при получении баланса: " + e.getStackTrace()[1] );
+//            log.error("Ошибка при получении баланса: " + e.getStackTrace()[2] );
+//            return -1;
+//        }
+
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/keysGenerator/KeyPairBase58.java

@@ -0,0 +1,26 @@
+package me.shineup.solana.internal.standartActions.keysGenerator;
+
+
+
+/**
+ * Объект, представляющий пару ключей Solana в формате Base58:
+ * - публичный ключ (32 байта)
+ * - приватный ключ (64 байта, включает публичный)
+ */
+public class KeyPairBase58 {
+    public final String publicKey;
+    public final String privateKey;
+
+    public KeyPairBase58(String publicKey, String privateKey) {
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+    }
+
+    @Override
+    public String toString() {
+        return "KeyPairBase58{\n" +
+                "  publicKey='" + publicKey + "',\n" +
+                "  privateKey='" + privateKey + "'\n" +
+                '}';
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/keysGenerator/SolanaKeyGeneratorManual.java

@@ -0,0 +1,101 @@
+package me.shineup.solana.internal.standartActions.keysGenerator;
+
+
+
+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
+import org.bouncycastle.crypto.generators.Ed25519KeyPairGenerator;
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
+import org.bouncycastle.crypto.KeyGenerationParameters;
+import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
+
+import java.security.SecureRandom;
+
+public class SolanaKeyGeneratorManual {
+
+    // ✅ Новый метод: возвращает пару ключей (в Base58)
+    public static KeyPairBase58 generateKeyPair() {
+        // Генератор ключей Ed25519
+        Ed25519KeyPairGenerator keyGen = new Ed25519KeyPairGenerator();
+        keyGen.init(new KeyGenerationParameters(new SecureRandom(), 256));
+        AsymmetricCipherKeyPair keyPair = keyGen.generateKeyPair();
+
+        Ed25519PrivateKeyParameters privateKeyParams = (Ed25519PrivateKeyParameters) keyPair.getPrivate();
+        Ed25519PublicKeyParameters publicKeyParams = (Ed25519PublicKeyParameters) keyPair.getPublic();
+
+        byte[] privateKey = privateKeyParams.getEncoded(); // 32 байта
+        byte[] publicKey = publicKeyParams.getEncoded();   // 32 байта
+
+        byte[] solanaSecretKey = new byte[64];
+        System.arraycopy(privateKey, 0, solanaSecretKey, 0, 32);
+        System.arraycopy(publicKey, 0, solanaSecretKey, 32, 32);
+
+        return new KeyPairBase58(
+                Base58.encode(publicKey),
+                Base58.encode(solanaSecretKey)
+        );
+    }
+
+
+
+    public static void main(String[] args) {
+        KeyPairBase58 keys = generateKeyPair();
+
+        System.out.println("✅ Сгенерирован новый кошелёк Solana:");
+        System.out.println("Публичный ключ (Base58): " + keys.publicKey);
+        System.out.println("Приватный ключ (Base58, 64 байта): " + keys.privateKey);
+
+        System.out.println();
+        System.out.println("String publicKey = \"" + keys.publicKey + "\";");
+        System.out.println("String privateKey = \"" + keys.privateKey + "\";");
+    }
+
+//
+//    // 👇 Встроенная реализация Base58 (без bitcoinj)
+    static class Base58 {
+        private static final char[] ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray();
+        private static final int BASE_58 = ALPHABET.length;
+
+        public static String encode(byte[] input) {
+            if (input.length == 0) return "";
+
+            // Count leading zeros.
+            int zeros = 0;
+            while (zeros < input.length && input[zeros] == 0) {
+                ++zeros;
+            }
+
+            // Convert base-256 digits to base-58 digits (plus conversion to ASCII characters)
+            int size = input.length * 2;
+            int[] encoded = new int[size];
+            int length = 0;
+
+            for (byte b : input) {
+                int carry = b & 0xFF;
+                int i = 0;
+                for (int j = size - 1; (carry != 0 || i < length) && j >= 0; j--, i++) {
+                    carry += 256 * encoded[j];
+                    encoded[j] = carry % BASE_58;
+                    carry /= BASE_58;
+                }
+                length = i;
+            }
+
+            // Skip leading zeros in encoded.
+            int encodedStart = size - length;
+            while (encodedStart < size && encoded[encodedStart] == 0) {
+                encodedStart++;
+            }
+
+            // Translate the result into a string.
+            StringBuilder result = new StringBuilder(zeros + size - encodedStart);
+            for (int i = 0; i < zeros; i++) {
+                result.append('1');
+            }
+            for (int i = encodedStart; i < size; i++) {
+                result.append(ALPHABET[encoded[i]]);
+            }
+
+            return result.toString();
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/transfer/SolanaTransfer.java

@@ -0,0 +1,73 @@
+package me.shineup.solana.internal.standartActions.transfer;
+
+import me.shineup.solana.exceptions.SolanaException_RpcConnection;
+import me.shineup.solana.internal.standartActions.balanse.SolanaBalanceChecker;
+import org.p2p.solanaj.core.Account;
+import org.p2p.solanaj.core.PublicKey;
+import org.p2p.solanaj.core.Transaction;
+import org.p2p.solanaj.rpc.RpcClient;
+import org.p2p.solanaj.rpc.RpcException;
+import org.p2p.solanaj.programs.SystemProgram;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.KeyUtils;
+
+import static me.shineup.solana.internal.utils.SolanaProgramCaller.getLatestBlockhash;
+import static me.shineup.solana.internal.utils.SolanaProgramCaller.sendTransactionWithBlockhash;
+
+public class SolanaTransfer {
+    private static final Logger log = LoggerFactory.getLogger(SolanaTransfer.class);
+
+    public static void main(String[] args) {
+        try {
+            Const.RPC_URL = Const.LOCAL_RPC_URL;
+            SolanaBalanceChecker.getBalance(Const.getKeyByName("key1").getPublicKey());
+            SolanaTransfer.sendSol(Const.getKeyByName("key1").getPrivateKey(), Const.getKeyByName("key2").getPublicKey(),100_000_000);
+            SolanaBalanceChecker.getBalance(Const.getKeyByName("key1").getPublicKey());
+            SolanaBalanceChecker.getBalance(Const.getKeyByName("key2").getPublicKey());
+        } catch (Exception e) {
+            log.error( e.getMessage());
+        }
+    }
+
+
+
+    /**
+     * Переводит lamports (1 SOL = 1_000_000_000 лампортов)
+     * @param fromBase58Secret - приватный ключ в виде массива из 64 байт
+     * @param toAddressBase58 - публичный ключ получателя
+     * @param lamports - сумма в лампортах
+     */
+    public static String sendSol(String fromBase58Secret, String toAddressBase58, long lamports) throws Exception{
+        try {
+
+            RpcClient rpc = new RpcClient(Const.RPC_URL);
+
+            byte[] senderSecretKey58 = KeyUtils.base58ToBytes(fromBase58Secret);
+
+            // Загружаем отправителя
+            Account from = new Account(senderSecretKey58);
+            PublicKey to = new PublicKey(toAddressBase58);
+
+            // Создаём транзакцию
+            Transaction transaction = new Transaction();
+            transaction.addInstruction(
+                    SystemProgram.transfer(from.getPublicKey(), to, lamports)
+            );
+
+            // Получаем blockhash
+            String recentBlockhash = getLatestBlockhash(rpc);
+
+            // отправляем транзакцию
+            String signature = sendTransactionWithBlockhash(rpc, transaction, recentBlockhash, from);
+
+
+            log.info("✅ Перевод " +  Const.lamportsToSol(lamports) + " отправлен с " + Const.identifyKey(fromBase58Secret) + " на " + Const.identifyKey(toAddressBase58) + " . Подпись: " + signature);
+            return signature;
+        } catch (RpcException e) {
+            throw new SolanaException_RpcConnection("❌ Ошибка RPC: " + e.getMessage());
+        }
+
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/KeyPair.java

@@ -0,0 +1,55 @@
+package me.shineup.solana.internal.utils;
+
+public class KeyPair {
+
+    public final String name;
+    public final String publicKey;
+    public final String privateKey;
+
+    public KeyPair(String name, String publicKey, String privateKey) {
+        this.name = name;
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPublicKey() {
+        return publicKey;
+    }
+
+    public String getPrivateKey() {
+        return privateKey;
+    }
+
+    @Override
+    public String toString() {
+        return "KeyPair{" +
+                "name='" + name + '\'' +
+                ", publicKey='" + publicKey + '\'' +
+                ", privateKey='" + privateKey + '\'' +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        KeyPair keyPair = (KeyPair) o;
+
+        if (!name.equals(keyPair.name)) return false;
+        if (!publicKey.equals(keyPair.publicKey)) return false;
+        return privateKey.equals(keyPair.privateKey);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = name.hashCode();
+        result = 31 * result + publicKey.hashCode();
+        result = 31 * result + privateKey.hashCode();
+        return result;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/KeyUtils.java

@@ -0,0 +1,39 @@
+package me.shineup.solana.internal.utils;
+
+
+import java.util.Arrays;
+
+public class KeyUtils {
+
+    private static final String BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+    public static byte[] base58ToBytes(String base58) {
+        // Простейший декодер Base58
+        int[] indexes = new int[128];
+        Arrays.fill(indexes, -1);
+        for (int i = 0; i < BASE58_ALPHABET.length(); i++) {
+            indexes[BASE58_ALPHABET.charAt(i)] = i;
+        }
+
+        byte[] input = new byte[base58.length()];
+        for (int i = 0; i < base58.length(); i++) {
+            input[i] = (byte) indexes[base58.charAt(i)];
+        }
+
+        byte[] result = new byte[64]; // длина ключа
+        int length = 0;
+
+        for (byte b : input) {
+            int carry = b & 0xFF;
+            int i = 0;
+            for (int j = result.length - 1; (carry != 0 || i < length) && j >= 0; j--, i++) {
+                carry += 58 * (result[j] & 0xFF);
+                result[j] = (byte) (carry % 256);
+                carry /= 256;
+            }
+            length = i;
+        }
+
+        return result;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/SolanaProgramCaller.java

@@ -0,0 +1,378 @@
+package me.shineup.solana.internal.utils;
+
+import me.shineup.solana.config.Const;
+import me.shineup.solana.exceptions.SolanaException;
+import me.shineup.solana.exceptions.SolanaException_InProgram;
+import me.shineup.solana.exceptions.SolanaException_InsufficientFundsForFee;
+import me.shineup.solana.exceptions.SolanaException_RpcConnection;
+import org.bitcoinj.core.Base58;
+import org.p2p.solanaj.core.*;
+import org.p2p.solanaj.rpc.RpcClient;
+import org.p2p.solanaj.rpc.RpcException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.net.ConnectException;
+import java.net.SocketTimeoutException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.*;
+
+import java.util.Map;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class SolanaProgramCaller {
+
+    // Логгер для вывода отладочной информации
+    private static final Logger log = LoggerFactory.getLogger(SolanaProgramCaller.class);
+
+    /**
+     * Универсальный метод вызова Anchor-функции на Solana.
+     *
+     * @param publicKeyB58   Публичный ключ вызывающего аккаунта в формате base58
+     * @param privateKeyB58  Приватный ключ в формате base58 (только первые 32 байта или полный 64-байтный seed)
+     * @param functionName   Имя функции Anchor (например: "register_user")
+     * @param programId      Адрес Anchor-программы, в которую делается вызов
+     * @param accounts       Список аккаунтов, необходимых для вызова (AccountMeta)
+     * @param serializedArgs Сериализованные аргументы вызова (без дискриминатора)
+     * @return base58-подпись транзакции или null при ошибке
+     */
+    public static String callAnchorFunction(
+            String publicKeyB58,
+            String privateKeyB58,
+            String functionName,
+            PublicKey programId,
+            List<AccountMeta> accounts,
+            byte[] serializedArgs
+    ) throws Exception {
+
+            // Создаём RPC клиент для взаимодействия с Solana (через URL, заданный в конфиге)
+            RpcClient rpc = new RpcClient(Const.RPC_URL);
+
+            // Декодируем публичный ключ вызывающего аккаунта из Base58 строки
+            PublicKey pubKey = new PublicKey(publicKeyB58);
+
+            // Декодируем приватный ключ из Base58 строки (ожидается 32 байта seed или 64 байта полного ключа)
+            byte[] priv = Base58.decode(privateKeyB58);
+
+            // Если длина приватного ключа всего 32 байта (seed), то дополняем его 32 байтами публичного ключа
+            if (priv.length == 32) {
+                byte[] full = new byte[64]; // 64-байтный ключ для Ed25519 (32 priv + 32 pub)
+                System.arraycopy(priv, 0, full, 0, 32); // копируем 32 байта приватного ключа
+                System.arraycopy(pubKey.toByteArray(), 0, full, 32, 32); // дописываем 32 байта публичного ключа
+                priv = full; // теперь priv содержит полный 64-байтный ключ
+            }
+
+            // Создаём объект аккаунта для подписи транзакции
+            Account signer = new Account(priv);
+
+            // Логируем вызов функции и аккаунт, от имени которого он будет происходить
+            log.debug("Вызов Anchor-функции '{}' от аккаунта {}", functionName, Const.identifyKey(pubKey.toBase58()));
+
+            // Генерируем Anchor-дискриминатор — первые 8 байт SHA-256 хеша строки "global:имя_функции"
+            byte[] discriminator = MessageDigest
+                    .getInstance("SHA-256") // используем SHA-256
+                    .digest(("global:" + functionName).getBytes(StandardCharsets.UTF_8)); // хешируем
+            discriminator = Arrays.copyOf(discriminator, 8); // берём только первые 8 байт (Anchor-дискриминатор)
+
+            // Формируем payload: сначала дискриминатор, потом сериализованные параметры
+            byte[] data = new byte[discriminator.length + serializedArgs.length];
+            System.arraycopy(discriminator, 0, data, 0, discriminator.length); // копируем дискриминатор
+            System.arraycopy(serializedArgs, 0, data, discriminator.length, serializedArgs.length); // копируем параметры
+
+            // Создаём инструкцию Solana-транзакции:
+            // - указываем ID программы (куда отправляем)
+            // - список аккаунтов, задействованных в вызове (AccountMeta)
+            // - подготовленные данные (дискриминатор + параметры)
+            TransactionInstruction instruction = new TransactionInstruction(
+                    programId, // ID Solana-программы (Anchor)
+                    accounts,  // список аккаунтов
+                    data       // бинарные данные вызова
+            );
+
+            // Создаём Solana транзакцию и добавляем в неё инструкцию
+            Transaction tx = new Transaction();
+            tx.addInstruction(instruction);
+
+
+            // Получаем blockhash
+            String recentBlockhash = getLatestBlockhash(rpc);
+
+            // отправляем транзакцию
+            String sig = sendTransactionWithBlockhash(rpc, tx, recentBlockhash, signer);
+
+            log.info("✅ Tx отправлена: {}", sig);
+
+            return sig; // возвращаем base58-подпись транзакции
+
+    }
+
+    // Вспомогательная склейка массивов
+    public static byte[] concat(byte[]... arrays) {
+        int length = 0;
+        for (byte[] a : arrays) length += a.length;
+        byte[] result = new byte[length];
+        int pos = 0;
+        for (byte[] a : arrays) {
+            System.arraycopy(a, 0, result, pos, a.length);
+            pos += a.length;
+        }
+        return result;
+    }
+
+
+    /**
+     * Сериализует аргументы Anchor/Borsh.
+     * Сейчас поддерживает: string, pubkey.
+     * - string  → 4-байтная длина (LE) + UTF-8
+     * - pubkey  → 32 байта
+     */
+    public static byte[] encodeAnchorArgs(List<String> types, List<Object> values) {
+        if (types.size() != values.size())
+            throw new IllegalArgumentException("Количество типов и значений должно совпадать");
+
+        ByteBuffer buf = ByteBuffer.allocate(1024).order(ByteOrder.LITTLE_ENDIAN);
+
+        for (int i = 0; i < types.size(); i++) {
+            String t = types.get(i);
+            Object v = values.get(i);
+
+
+            switch (t) {
+                case "string": {
+                    byte[] s = (byte[]) v;                 // уже UTF-8 байты
+                    buf.putInt(s.length);                 // 4-byte length LE
+                    buf.put(s);
+                    break;
+                }
+                case "pubkey": {
+                    byte[] pk = (byte[]) v;
+                    if (pk.length != 32)
+                        throw new IllegalArgumentException("Pubkey должен быть 32 байта");
+                    buf.put(pk);
+                    break;
+                }
+                default:
+                    throw new UnsupportedOperationException("Неизвестный тип: " + t);
+            }
+        }
+        byte[] out = new byte[buf.position()];
+        buf.flip();
+        buf.get(out);
+        return out;
+    }
+
+
+    /*------------------------------------------------------------
+     * 1. Получаем актуальный blockhash
+     *-----------------------------------------------------------*/
+    @SuppressWarnings("unchecked")
+    public static String getLatestBlockhash(RpcClient rpc) throws Exception {
+
+        Map<String, Object> commitment = new HashMap<String, Object>();
+        commitment.put("commitment", "finalized");
+
+        Map<String, Object> bhJson;
+        try {
+            bhJson = rpc.call(
+                    "getLatestBlockhash",
+                    Collections.<Object>singletonList(commitment),
+                    Map.class
+            );
+            // остальной код
+        } catch (Exception e) {
+            throw new SolanaException_RpcConnection("Неудаётся соедениться при попытке получить blockhash: " + e.getMessage());
+        }
+
+        // --- проверка ответа + поддержка обоих форматов ---
+        if (bhJson == null) {
+            throw new SolanaException("При получении номера последнего блока RPC вернул null");
+        }
+        if (bhJson.containsKey("error")) {
+            throw new SolanaException("При получении номера последнего блока: RPC error: " + bhJson.get("error"));
+        }
+
+        Map<String, Object> value;
+        if (bhJson.containsKey("result")) {
+            Map<String, Object> result = (Map<String, Object>) bhJson.get("result");
+            value = (Map<String, Object>) result.get("value");
+        } else {
+            value = (Map<String, Object>) bhJson.get("value");
+        }
+
+        if (value == null) {
+            throw new SolanaException("При получении номера последнего блока: Поле \"value\" отсутствует. Ответ: " + bhJson);
+        }
+        String recentBlockhash = (String) value.get("blockhash");
+        if (recentBlockhash == null) {
+            throw new SolanaException("При получении номера последнего блока: Поле \"blockhash\" отсутствует. Ответ: " + bhJson);
+        }
+
+        return recentBlockhash;
+    }
+
+    /*------------------------------------------------------------
+     * 2. Подписываем и отправляем транзакцию, зная blockhash
+     *-----------------------------------------------------------*/
+    public static String sendTransactionWithBlockhash(
+            RpcClient rpc,
+            Transaction tx,
+            String recentBlockhash,
+            Account... signers
+    ) throws Exception {
+
+        /* ---- подставляем hash ---- */
+        tx.setRecentBlockHash(recentBlockhash);
+
+        /* ---- подписываем ---- */
+        if (signers.length == 0) {
+            throw new IllegalArgumentException("Нужен хотя бы один подписант");
+        } else if (signers.length == 1) {
+            tx.sign(signers[0]);
+        } else {
+            tx.sign(Arrays.asList(signers));
+        }
+
+
+/**        // можно сериализовывать в базу 64 и в базу 58    // пока оставил 58
+//        // ---- сериализация в база 64 ----
+//        String b64Tx = Base64.getEncoder()
+//                .encodeToString(tx.serialize());
+//
+//        // ---- отправка ----
+//        Map<String, Object> cfg = new HashMap<String, Object>();
+//        cfg.put("skipPreflight", Boolean.FALSE); //Boolean.TRUE);
+//
+//        cfg.put("encoding", "base64");          // ← ключевое добавление!
+//
+//
+//        return rpc.call(
+//                "sendTransaction",
+//                Arrays.asList(b64Tx, cfg),
+//                String.class
+//        );
+        */
+
+        /* ---- сериализация и отправка в база 58 ---- */
+        byte[] txBytes = tx.serialize();
+        String base58EncodedTx = Base58.encode(txBytes);
+
+        Map<String, Object> cfg = new HashMap<>();
+        cfg.put("skipPreflight", false); // если false - то транзакцию сразу проверяют на ошибки
+
+        try {
+            return rpc.call(
+                    "sendTransaction",
+                    Arrays.asList(base58EncodedTx, cfg),
+                    String.class
+            );
+        } catch (RpcException e) {
+            /* ---------- низкоуровневые сетевые ошибки (не достучались до RPC) */
+            Throwable cause = e.getCause();
+            if (cause instanceof ConnectException) {
+                throw new SolanaException_RpcConnection("Не удалось подключиться к RPC-узлу: " + cause.getMessage());
+            }
+            if (cause instanceof SocketTimeoutException) {
+                throw new SolanaException_RpcConnection("Время ожидания ответа RPC истекло");
+            }
+
+            /* ---------- парсинг сообщения об ошибке от RPC/симуляции -------- */
+            String err = Objects.toString(e.getMessage(), "");
+
+            /* 1) Стандартные InstructionError-ы */
+            if (err.contains("\"InstructionError\"")) {
+                // Чаще всего приходит: "InstructionError": [0,"InsufficientFunds"]
+                if (err.contains("InsufficientFunds")) {
+                    throw new SolanaException_InsufficientFundsForFee();
+                }
+//                if (err.contains("AccountNotFound")) {
+//                    throw new SolanaException_AccountNotFound();
+//                }
+//                if (err.contains("InvalidAccountData")) {
+//                    throw new SolanaException_InvalidAccountData();
+//                }
+//                if (err.contains("InstructionMissing")) {
+//                    throw new SolanaException_InstructionMissing();
+//                }
+//                if (err.contains("UninitializedAccount")) {
+//                    throw new SolanaException_UninitializedAccount();
+//                }
+//                if (err.contains("IncorrectProgramId")) {
+//                    throw new SolanaException_IncorrectProgramId();
+//                }
+            }
+
+            /* ) Отдельная проверка на ошибку дебета с пустого аккаунта */
+            if (err.contains("insufficient funds for rent")             // или такое сообщение если акаунт пуст
+                    || err.matches("(?i).*custom program error: 0x0*1\\b.*")) {    // или такое если денег не хватает
+                throw new SolanaException_InsufficientFundsForFee();
+            }
+
+            /* 2) Кастомная ошибка из твоей программы: "custom program error: 0xXXXX" */
+            Pattern p = Pattern.compile("custom program error: (0x[0-9a-fA-F]+)");
+            Matcher m = p.matcher(err);
+            if (m.find()) {
+                String hexCode = m.group(1);
+                int decimalCode = Integer.parseInt(hexCode.substring(2), 16);
+                throw new SolanaException_InProgram(decimalCode);
+            }
+
+            /* 3) Прочие симуляционные ошибки (можно расширять по вкусу) */
+//            if (err.contains("Transaction simulation failed")) {
+//                throw new SolanaException(
+//                        "Симуляция транзакции завершилась ошибкой: " + err
+//                );
+//            }
+
+            /* 4) Всё остальное – оборачиваем как «неизвестную» */
+            throw new SolanaException("RPC-ошибка: " + err, e);
+
+        }
+    }
+
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/SolanaRpcClient.java

@@ -0,0 +1,86 @@
+package me.shineup.solana.internal.utils;
+
+import me.shineup.solana.config.Const;
+import me.shineup.solana.exceptions.SolanaException_RpcConnection;
+import me.shineup.solana.exceptions.SolanaErrorHandler;
+import okhttp3.MediaType;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.io.IOException;
+
+public class SolanaRpcClient {
+
+    private static final Logger log = LoggerFactory.getLogger(SolanaRpcClient.class);
+    private static SolanaRpcClient instance;
+
+    private final OkHttpClient httpClient;
+    private final String rpcUrl;
+
+    private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
+
+    private SolanaRpcClient(String rpcUrl) {
+        this.rpcUrl = rpcUrl;
+        this.httpClient = new OkHttpClient();
+    }
+
+    public static SolanaRpcClient getInstance() {
+        if (instance == null) {
+            instance = new SolanaRpcClient(Const.RPC_URL);
+        }
+        return instance;
+    }
+
+    public static SolanaRpcClient withCustomUrl(String customUrl) {
+        instance = new SolanaRpcClient(customUrl);
+        return instance;
+    }
+
+    /**
+     * Выполняет JSON-RPC запрос и возвращает ответ как строку.
+     * В случае ошибки — выбрасывает RpcConnectionException.
+     */
+    public String sendRequest(String jsonRequest) throws SolanaException_RpcConnection {
+        log.debug("📤 Отправка RPC-запроса: {}", jsonRequest);
+
+        RequestBody body = RequestBody.create(jsonRequest, JSON);
+
+        Request request = new Request.Builder()
+                .url(rpcUrl)
+                .post(body)
+                .addHeader("Content-Type", "application/json")
+                .build();
+
+        try (Response response = httpClient.newCall(request).execute()) {
+            if (!response.isSuccessful()) {
+                log.error("❌ RPC ответ с ошибкой: {} {}", response.code(), response.message());
+                throw new SolanaException_RpcConnection("RPC ответ с ошибкой: " + response.code() + " " + response.message());
+            }
+
+            if (response.body() == null) {
+                log.error("❌ RPC вернул пустое тело");
+                throw new SolanaException_RpcConnection("Пустой ответ от RPC");
+            }
+
+            String responseText = response.body().string();
+            log.debug("📥 Получен ответ от RPC: {}", responseText);
+
+            // ✅ Обработка ошибок, если в ответе есть error
+            if (responseText.contains("\"error\"")) {
+                SolanaErrorHandler.handleRpcJsonError(responseText);
+            }
+
+            return responseText;
+
+        } catch (IOException e) {
+            log.error("❌ Ошибка подключения к RPC: {}", e.toString());
+            throw new SolanaException_RpcConnection("Ошибка подключения к RPC" + e.toString());
+        } catch (Exception e) {
+            log.error("❌ Непредвиденная ошибка при вызове RPC: {}", e.toString());
+            throw new SolanaException_RpcConnection("Непредвиденная ошибка RPC" + e.toString());
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/jsonrpc/JsonRpcRequest.java

@@ -0,0 +1,19 @@
+package me.shineup.solana.internal.utils.jsonrpc;
+
+
+
+import java.util.List;
+
+
+/**  странная фигня котыль который пришлось добавить при переходе на старую библиотеку solanaj для джава 8   */
+public class JsonRpcRequest {
+    public String jsonrpc = "2.0";
+    public String method;
+    public List<Object> params;
+    public int id = 1;
+
+    public JsonRpcRequest(String method, List<Object> params) {
+        this.method  = method;
+        this.params  = params;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/reader/PdaReader.java

@@ -0,0 +1,157 @@
+package me.shineup.solana.internal.utils.reader;
+
+
+import me.shineup.solana.exceptions.SolanaException_RpcConnection;
+import me.shineup.solana.exceptions.SolanaException;
+import org.p2p.solanaj.core.PublicKey;
+import org.p2p.solanaj.rpc.RpcClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+
+/**
+ * Чтение произвольного PDA-аккаунта в актуальных кластерах Solana (v1.18+).
+ *
+ * ───────────────────────────────────────────────────────────────────────────────
+ * ▸ Solana HTTP RPC:  getAccountInfo
+ *
+ *   {
+ *     "jsonrpc":"2.0",
+ *     "id":1,
+ *     "result":{
+ *       "context":{"slot":123456},
+ *       "value":{
+ *         "data":[                // 0 - base64-строка, 1 - "base64"
+ *             "BASE64_STRING",
+ *             "base64"
+ *         ],
+ *         "executable":false,
+ *         "lamports":2039280,
+ *         "owner":"BPFLoaderUpgradeab1e11111111111111111111111",
+ *         "rentEpoch":"18446744073709551615"   // - строка-u64 (v1.18+)
+ *       }
+ *     }
+ *   }
+ *
+ * ▸ Мы читаем только  value.data[0]  (Base64)  – остальное не трогаем,
+ *   поэтому не важен тип rentEpoch (строка или число).
+ * ───────────────────────────────────────────────────────────────────────────────
+ */
+public final class PdaReader {
+
+    /* --------------------------------------------------------------------- */
+    /*  CONFIG & LOG                                                         */
+    /* --------------------------------------------------------------------- */
+    private static final Logger LOG = LoggerFactory.getLogger(PdaReader.class);
+    private static final RpcClient RPC = new RpcClient(Const.RPC_URL); // один клиент на класс
+
+    private PdaReader() {} // запретить new
+
+    /* --------------------------------------------------------------------- */
+    /*  PUBLIC API                                                           */
+    /* --------------------------------------------------------------------- */
+
+    /** Чтение PDA, вычисленного из одного текстового сида. */
+    public static byte[] readOneSeed(String seed, String programId) throws Exception {
+        PublicKey pda = derivePda(Collections.singletonList(seed.getBytes(StandardCharsets.UTF_8)),
+                programId);
+        return fetchAccountData(pda);
+    }
+
+    /** Чтение PDA, вычисленного из двух произвольных сид-массивов. */
+    public static byte[] readTwoSeeds(byte[] seed1, byte[] seed2, String programId) throws Exception {
+        PublicKey pda = derivePda(Arrays.asList(seed1, seed2), programId);
+        return fetchAccountData(pda);
+    }
+
+    /* --------------------------------------------------------------------- */
+    /*  INTERNALS                                                            */
+    /* --------------------------------------------------------------------- */
+
+    /** Высчитываем адрес PDA для списка сидов. */
+    private static PublicKey derivePda(List<byte[]> seeds, String programId) throws Exception {
+        PublicKey program = new PublicKey(programId);
+        PublicKey pda = PublicKey.findProgramAddress(seeds, program).getAddress();
+        LOG.info("📡 PDA адрес: {}", pda.toBase58());
+        return pda;
+    }
+
+    /**
+     * Достаём бинарные данные аккаунта.<br>
+     * Возвращает <code>null</code>, если аккаунт отсутствует или пуст.
+     */
+
+
+    @SuppressWarnings("unchecked")
+    private static byte[] fetchAccountData(PublicKey pda) throws Exception {
+
+        // 1) getAccountInfo c base64-энкодингом
+        Map<String,Object> cfg = new HashMap<>();
+        cfg.put("encoding", "base64");
+        cfg.put("commitment", "confirmed");
+
+//        Map<String,Object> resp = RPC.call(
+//                "getAccountInfo",
+//                Arrays.asList(pda.toBase58(), cfg),
+//                Map.class                         // сырое дерево
+//        );
+
+
+
+        Map<String, Object> resp;
+        try {
+            resp = RPC.call(
+                    "getAccountInfo",
+                    Arrays.asList(pda.toBase58(), cfg),
+                    Map.class
+            );
+        } catch (Exception e) {             // solanaj бросает RuntimeException/IOException
+            throw new SolanaException_RpcConnection("Не удалось выполнить getAccountInfo");
+        }
+
+        // Если RPC вернул стандартное поле error — разбираем его централизованно
+        if (resp.get("error") != null) {
+            throw new SolanaException("RPC вернул поле error"); //тут можно добавить вывод что за конкретная ошибка случилась
+        }
+
+        // 2) Достаём value → data[0]
+//        Map<String,Object> result = (Map<String,Object>) resp.get("result");
+//        if (result == null) return null;
+
+
+        Map<String,Object> value  = (Map<String,Object>) resp.get("value");//result.get("value");
+        if (value == null) return null;
+
+        List<?> dataArr = (List<?>) value.get("data");
+        if (dataArr == null || dataArr.isEmpty()) return null;
+
+        String b64 = (String) dataArr.get(0);   // ← вот он payload
+        if (b64 == null || b64.isEmpty()) return null;
+
+        return Base64.getDecoder().decode(b64);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void debugDumpJson(Object node, int indent) {
+        String pad = String.join("", Collections.nCopies(indent, "  ")); // два пробела × indent
+        if (node instanceof Map) {
+            Map<String, Object> map = (Map<String, Object>) node;
+            for (Map.Entry<String, Object> e : map.entrySet()) {
+                System.out.println(pad + e.getKey() + ":");
+                debugDumpJson(e.getValue(), indent + 1);
+            }
+        } else if (node instanceof Iterable) {
+            Iterable<?> it = (Iterable<?>) node;
+            for (Object val : it) {
+                debugDumpJson(val, indent + 1);
+            }
+        } else {
+            System.out.println(pad + String.valueOf(node));
+        }
+    }
+
+
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/ResultChecker.java

@@ -0,0 +1,29 @@
+package me.shineup.solana.internal.utils.resultChecker;
+
+
+/**
+ * Утилита для проверки результата выполнения транзакции по подписи.
+ *
+ * Данный класс:
+ *  - выводит подпись транзакции в консоль
+ *  - ждёт подтверждения транзакции через Solana RPC
+ *  - выводит статус транзакции после завершения
+ */
+public class ResultChecker {
+
+    /**
+     * Проверяет статус транзакции по её подписи.
+     *
+     * @param sig Подпись (signature) транзакции в base58-формате.
+     */
+    public static void check(String sig) {
+        System.out.println("📦 Signature: " + sig);
+
+        if (sig != null) {
+            TransactionStatusChecker.waitForConfirmation(sig);
+            SolanaTransactionStatusChecker.getTransactionStatus(sig);
+        } else {
+            System.out.println("⚠️ Подпись транзакции пуста или null");
+        }
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/SolanaTransactionStatusChecker.java

@@ -0,0 +1,210 @@
+package me.shineup.solana.internal.utils.resultChecker;
+
+import me.shineup.solana.config.Const;
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.internal.utils.SolanaRpcClient;
+
+public class SolanaTransactionStatusChecker {
+
+    private static final Logger log = LoggerFactory.getLogger(SolanaTransactionStatusChecker.class);
+    private static final Gson gson = new Gson();
+
+
+    public static boolean getTransactionStatus(String signature) {
+        boolean isOk = false;
+        String requestJson = String.format(
+                "{\n" +
+                        "  \"jsonrpc\": \"2.0\",\n" +
+                        "  \"id\": 1,\n" +
+                        "  \"method\": \"getTransaction\",\n" +
+                        "  \"params\": [\"%s\", { \"encoding\": \"jsonParsed\", \"commitment\": \"finalized\" }]\n" +
+                        "}", signature);
+
+//        String requestJson = """
+//    {
+//      "jsonrpc": "2.0",
+//      "id": 1,
+//      "method": "getTransaction",
+//      "params": ["%s", { "encoding": "jsonParsed", "commitment": "finalized" }]
+//    }
+//    """.formatted(signature);
+
+
+        try {
+            String responseJson = SolanaRpcClient.getInstance().sendRequest(requestJson);
+            JsonObject root = gson.fromJson(responseJson, JsonObject.class);
+
+            if (root.has("error")) {
+                log.error("❌ Ошибка при запросе транзакции: {}", root.get("error"));
+                return false;
+            }
+
+            JsonElement resultElement = root.get("result");
+
+            if (resultElement == null || resultElement.isJsonNull()) {
+                log.warn("⚠️ Транзакция с сигнатурой {} не найдена или ещё не финализирована", signature);
+                return false;
+            }
+
+            JsonObject result = root.getAsJsonObject("result");
+
+            if (result == null) {
+                log.warn("⚠️ Транзакция с сигнатурой {} не найдена", signature);
+                return false;
+            }
+
+            JsonObject meta = result.getAsJsonObject("meta");
+            if (meta == null) {
+                log.warn("⚠️ Нет информации о результате выполнения");
+                return false;
+            }
+
+            JsonElement err = meta.get("err");
+            if (err == null || err.isJsonNull()) {
+                log.info("✅ Транзакция завершилась успешно");
+                isOk = true;
+            } else {
+                log.warn("⚠️ Транзакция завершилась с ошибкой. Код ошибки: {}", extractCustomErrorCode(err));
+                isOk = false;
+            }
+
+
+            // 💸 Вывод комиссии
+            if (meta.has("fee")) {
+                long fee = meta.get("fee").getAsLong();
+                log.info("💸 Комиссия за транзакцию: {} лампортов", fee);
+            }
+
+            // Получаем message → accountKeys
+            JsonObject message = result.getAsJsonObject("transaction").getAsJsonObject("message");
+            JsonArray accountKeys = message.getAsJsonArray("accountKeys");
+
+            // 🔄 Выводим изменения балансов
+            logBalanceChanges(meta, accountKeys);
+
+            // 💸 Общая сумма списанных лампортов (не только комиссия)
+            long totalSpent = calculateTotalSpent(meta);
+            log.info("💸 Общая сумма списанных лампортов (включая переводы и аренду аккаунтов): {}", totalSpent);
+
+
+            // Выводим лог исполнения (если есть)
+            if (meta.has("logMessages")) {
+                JsonElement logsElement = meta.get("logMessages");
+                if (logsElement != null && logsElement.isJsonArray()) {
+                    JsonArray logs = logsElement.getAsJsonArray();
+                    log.info("📝 Логи исполнения:");
+                    for (JsonElement logLine : logs) {
+                        log.info("  → " + logLine.getAsString());
+                    }
+                } else if (logsElement != null && logsElement.isJsonNull()) {
+                    log.info("📝 Логи исполнения: отсутствуют (null)");
+                } else {
+                    log.warn("📝 Логи исполнения: неожиданный формат данных");
+                }
+            }
+
+        } catch (Exception e) {
+            log.error("❌ Ошибка при запросе статуса транзакции", e);
+            return false;
+        }
+        return isOk;
+    }
+
+
+
+
+    /**
+     * Извлекает значение Custom Anchor ошибки из поля "err", если оно есть.
+     *
+     * Пример ожидаемого JSON:
+     * {
+     *   "InstructionError": [0, { "Custom": 10000 }]
+     * }
+     *
+     * @param errJson поле "err" из ответа Solana
+     * @return числовой код ошибки (например, 10000) или null, если не найден
+     */
+    public static Integer extractCustomErrorCode(JsonElement errJson) {
+        if (errJson == null || errJson.isJsonNull()) return null;
+
+        try {
+            JsonObject errObj = errJson.getAsJsonObject();
+            if (errObj.has("InstructionError")) {
+                JsonArray instrError = errObj.getAsJsonArray("InstructionError");
+
+                if (instrError.size() == 2 && instrError.get(1).isJsonObject()) {
+                    JsonObject customObj = instrError.get(1).getAsJsonObject();
+                    if (customObj.has("Custom")) {
+                        return customObj.get("Custom").getAsInt();
+                    }
+                }
+            }
+        } catch (Exception e) {
+            // безопасно возвращаем null
+        }
+
+        return null;
+    }
+
+
+    /**
+     * Логирует изменения балансов всех аккаунтов, участвующих в транзакции.
+     *
+     * @param meta         JSON-объект "meta" из транзакции (включает preBalances и postBalances)
+     * @param accountKeys  Список accountKeys из message (содержит pubkey для каждого аккаунта)
+     */
+    public static void logBalanceChanges(JsonObject meta, JsonArray accountKeys) {
+        JsonArray preBalances = meta.getAsJsonArray("preBalances");
+        JsonArray postBalances = meta.getAsJsonArray("postBalances");
+
+        log.info("💰 Изменения балансов по аккаунтам:");
+
+        for (int i = 0; i < preBalances.size(); i++) {
+            long pre = preBalances.get(i).getAsLong();
+            long post = postBalances.get(i).getAsLong();
+            long delta = post - pre;
+
+            String pubkey = accountKeys.get(i)
+                    .getAsJsonObject()
+                    .get("pubkey")
+                    .getAsString();
+
+            double usdValue = delta * 150.0 / 1_000_000_000;
+            String usdFormatted = String.format("%.5f", usdValue);
+
+            log.info("🔄 {}: {} → {} (Δ: {} лампортов) ≈ {} $", Const.identifyKey(pubkey), pre, post, delta, usdFormatted);
+
+
+        }
+    }
+
+    /**
+     * Считает общую сумму списанных лампортов по всем аккаунтам,
+     * т.е. где postBalance < preBalance.
+     *
+     * @param meta JSON-объект "meta" из транзакции
+     * @return общее количество списанных лампортов
+     */
+    public static long calculateTotalSpent(JsonObject meta) {
+        JsonArray preBalances = meta.getAsJsonArray("preBalances");
+        JsonArray postBalances = meta.getAsJsonArray("postBalances");
+
+        long totalSpent = 0;
+
+        for (int i = 0; i < preBalances.size(); i++) {
+            long pre = preBalances.get(i).getAsLong();
+            long post = postBalances.get(i).getAsLong();
+
+            if (post < pre) {
+                totalSpent += (pre - post);
+            }
+        }
+
+        return totalSpent;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/TransactionStatusChecker.java

@@ -0,0 +1,68 @@
+package me.shineup.solana.internal.utils.resultChecker;
+
+import org.p2p.solanaj.rpc.RpcClient;
+import org.p2p.solanaj.rpc.types.SignatureStatuses;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import me.shineup.solana.config.Const;
+
+import java.util.Collections;
+import java.util.List;
+
+public class TransactionStatusChecker {
+
+    private static final Logger LOG = LoggerFactory.getLogger(TransactionStatusChecker.class);
+
+    /**
+     * Проверяет статус транзакции по подписи, делает до 10 попыток с паузой.
+     *
+     * @param signature Подпись транзакции (Base58)
+     * @return true, если транзакция прошла успешно, иначе false
+     */
+    public static boolean waitForConfirmation(String signature) {
+        RpcClient rpc = new RpcClient(Const.RPC_URL);
+
+        try {
+            for (int attempt = 1; attempt <= 10; attempt++) {
+                LOG.info("🔍 Попытка {} проверки транзакции {}", attempt, signature);
+
+                SignatureStatuses statuses = rpc.getApi().getSignatureStatuses(Collections.singletonList(signature), true);
+                List<SignatureStatuses.Value> infoList = statuses.getValue();
+
+                if (infoList != null && !infoList.isEmpty()) {
+                    SignatureStatuses.Value info = infoList.get(0);
+
+                    if (info != null) {
+                        String status = info.getConfirmationStatus(); // Или getConfirmationStatusString() в других версиях
+
+                        LOG.info("⏳ Статус: {}", status);
+                        if ("finalized".equals(status)) {
+                            LOG.info("🎉 Финализирована большинством");
+                            //todo
+                            return true;
+                        } else if ("processed".equals(status)) {
+                            LOG.info("Транзакция принята в пул");
+                        } else if ("confirmed".equals(status)) {
+                            LOG.info("Транзакция вошла в блок, но не финализирована");
+                        } else {
+                            LOG.info("Хер его знает ");
+                        }
+
+                    } else {
+                        LOG.info("Пока такой транзакции нету");
+                    }
+                } else {
+                    LOG.info("Запрос вообще не удался");
+                }
+
+                Thread.sleep(3000); // Ждать 3 секунды перед следующей попыткой
+            }
+
+            LOG.warn("❌ Транзакция не подтвердилась за 10 попыток: {}", signature);
+        } catch (Exception e) {
+            LOG.error("❌ Ошибка при проверке транзакции", e);
+        }
+
+        return false;
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/TransactionStatusHelper.java

@@ -0,0 +1,126 @@
+package me.shineup.solana.internal.utils.resultChecker;
+
+// Демонстрационный класс: единая точка проверки статуса транзакции Solana
+// ----------------------------------------------------------------------
+// Содержит:
+//  1. Enum TxStatus – перечень возможных состояний
+//  2. Статический метод getTxStatus(...) – собственно проверка
+//  3. Метод main(...) – пример использования
+// ----------------------------------------------------------------------
+
+import java.util.Collections;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import me.shineup.solana.config.Const;
+import me.shineup.solana.internal.utils.SolanaRpcClient;
+import me.shineup.solana.model.TxStatus;
+import org.p2p.solanaj.rpc.RpcClient;
+import org.p2p.solanaj.rpc.types.SignatureStatuses;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TransactionStatusHelper {
+
+//    // --------------------------------------------------
+//    // 1. Enum – возможные состояния транзакции
+//    // --------------------------------------------------
+//    public enum TxStatus {
+//            // ✅ Повторять запрос, если лимит времени не исчерпан:
+//        NOT_FOUND,          // RPC‑узел ещё не видел подпись */
+//        PROCESSED,          // Подпись обработана, но не попала в блок
+//        CONFIRMED,          // Транзакция в блоке, но блок не финализирован
+//
+//            //❌ Не повторять, даже если лимит не исчерпан:
+//        FINALIZED_SUCCESS,  // Блок финализирован и meta.err == null
+//        FINALIZED_ERROR,    // Блок финализирован, но meta.err содержит ошибку
+//            //⚠️ Не повторять или повторять ограниченно (1–3 раза, или ≤ N секунд):
+//        UNKNOWN,            // Не удалось определить статус (RPC‑ошибка, исключение и т.д.) */
+//        NETWORK_ERROR       // Не удаётся подключиться по сете
+//    }
+
+    // --------------------------------------------------
+    // 2. Метод проверки статуса
+    // --------------------------------------------------
+    private static final Logger log = LoggerFactory.getLogger(TransactionStatusHelper.class);
+
+    /**
+     * Универсальная проверка статуса транзакции.
+     * @param signature подпись (transaction signature / id)
+     * @return текущее состояние {@link TxStatus}
+     */
+    public static TxStatus getTxStatus(String signature) {
+        RpcClient rpc = new RpcClient(Const.RPC_URL);
+
+        try {
+            // --- 1. Быстрый запрос STATUSES
+            // Пробуем получить статус транзакции
+            SignatureStatuses.Value info;
+            try {
+                info = rpc.getApi()
+                        .getSignatureStatuses(Collections.singletonList(signature), true)
+                        .getValue()
+                        .get(0);
+            } catch (Exception e) {
+                log.error("🔌 Ошибка подключения к RPC или сети", e);
+                return TxStatus.NETWORK_ERROR;  // Тут можно вернуть специальный статус NETWORK_ERROR, если нужно точнее
+            }
+
+
+
+            if (info == null) {
+                return TxStatus.NOT_FOUND; // подпись ещё не дошла до RPC
+            }
+
+            String commit = info.getConfirmationStatus(); // processed / confirmed / finalized
+
+            switch (commit) {
+                case "processed":
+                    return TxStatus.PROCESSED;
+                case "confirmed":
+                    return TxStatus.CONFIRMED;
+                case "finalized":
+                    // --- 2. Дошли до финала – нужен getTransaction, чтобы узнать err
+                    String reqJson = String.format(
+                            "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"getTransaction\"," +
+                                    "\"params\":[\"%s\",{\"encoding\":\"json\",\"commitment\":\"finalized\"}]}",
+                            signature);
+
+                    // SolanaRpcClient – ваша внутренняя обёртка. Замените на свой http‑клиент.
+                    String raw = SolanaRpcClient.getInstance().sendRequest(reqJson);
+
+                    JsonObject meta = JsonParser.parseString(raw)
+                            .getAsJsonObject()
+                            .getAsJsonObject("result")
+                            .getAsJsonObject("meta");
+
+                    return meta.get("err").isJsonNull() ? TxStatus.FINALIZED_SUCCESS : TxStatus.FINALIZED_ERROR;
+                default:
+                    return TxStatus.UNKNOWN;
+            }
+
+        } catch (Exception e) {
+            log.error("RPC error while checking {}", signature, e);
+            return TxStatus.UNKNOWN;
+        }
+    }
+
+    // --------------------------------------------------
+    // 3. Пример использования
+    // --------------------------------------------------
+    /**
+     * Точка входа для быстрого ручного теста.
+     * Запускайте так:
+     *   java TransactionStatusHelper <signature>
+     * Если аргумент не передан, используется демо‑подпись.
+     */
+    public static void main(String[] args) {
+        // Подпись можно передать первым аргументом
+        String sig = (args.length > 0)
+                ? args[0]
+                : "4bxeRu4pNk9UzN6QgTPy6Q3DLJ6ZQt3xMkUQnDzohBpxjMVqRyba2Riqm8o7MBYo2YfSfvqbMFxRRWwu1XbbeiKf";
+
+        TxStatus status = getTxStatus(sig);
+        System.out.println("Статус транзакции " + sig + " → " + status);
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/TxStatus.java

@@ -0,0 +1,22 @@
+package me.shineup.solana.model;
+
+/**
+ * Статус транзакции в Solana.
+ * Используется для отслеживания состояния по сигнатуре.
+ */
+// --------------------------------------------------
+// 1. Enum – возможные состояния транзакции
+// --------------------------------------------------
+public enum TxStatus {
+    // ✅ Повторять запрос, если лимит времени не исчерпан:
+    NOT_FOUND,          // RPC‑узел ещё не видел подпись */
+    PROCESSED,          // Подпись обработана, но не попала в блок
+    CONFIRMED,          // Транзакция в блоке, но блок не финализирован
+
+    //❌ Не повторять, даже если лимит не исчерпан:
+    FINALIZED_SUCCESS,  // Блок финализирован и meta.err == null
+    FINALIZED_ERROR,    // Блок финализирован, но meta.err содержит ошибку
+    //⚠️ Не повторять или повторять ограниченно (1–3 раза, или ≤ N секунд):
+    UNKNOWN,            // Не удалось определить статус (RPC‑ошибка, исключение и т.д.) */
+    NETWORK_ERROR       // Не удаётся подключиться по сете
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/UserById.java

@@ -0,0 +1,52 @@
+package me.shineup.solana.model;
+
+
+import java.util.List;
+
+/**
+ * Java-представление Solana-структуры UserById.
+ *
+ * Содержит:
+ *  • format         – версия сериализации;
+ *  • id             – числовой ID пользователя;
+ *  • login          – строковый логин;
+ *  • pubkey         – публичная подпись пользователя (Base58);
+ *  • deviceCount    – сколько устройств хранится;
+ *  • devices        – список устройств (DeviceInfo).
+ */
+public class UserById {
+
+    /* ---------- поля, идущие в сериализации ---------- */
+    public int format;
+    public long id;
+    public String login;
+    public String pubkey;
+    public int deviceCount;
+    public List<DeviceInfo> devices;
+
+    /** Вложенный класс описания одного устройства. */
+    public static class DeviceInfo {
+        public int deviceType;      // 1 байт в on-chain
+        public String devicePubkey; // 32 байта (Base58)
+        public String x25519Pubkey; // 32 байта (Base58)
+
+        @Override
+        public String toString() {
+            return "DeviceInfo{type=" + deviceType +
+                    ", devPub=" + devicePubkey +
+                    ", x25519=" + x25519Pubkey + '}';
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "UserById{" +
+                "format=" + format +
+                ", id=" + id +
+                ", login='" + login + '\'' +
+                ", pubkey='" + pubkey + '\'' +
+                ", deviceCount=" + deviceCount +
+                ", devices=" + devices +
+                '}';
+    }
+}

solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/UserByLogin.java

@@ -0,0 +1,23 @@
+package me.shineup.solana.model;
+
+/**
+ * Класс описывающий объект UserByLogin, аналогичный структуре на стороне Solana.
+ */
+public class UserByLogin {
+    public int format;      // формат сериализации (например, 1)
+    public String login;    // логин
+    public long id;         // числовой ID
+    public String pubkey;   // публичный ключ (base58)
+    public int status;      // статус (например, 0)
+
+    @Override
+    public String toString() {
+        return "UserByLogin{" +
+                "format=" + format +
+                ", login='" + login + '\'' +
+                ", id=" + id +
+                ", pubkey='" + pubkey + '\'' +
+                ", status=" + status +
+                '}';
+    }
+}

solana-shine-client-lib/src/main/Build.txt

@@ -0,0 +1,2 @@
+./gradlew :solana-shine-lib:build
+- команда что бы сбилдить библиотеку