Aidar/shine-solana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
AidarKC 2026-05-04 14:19:40 +03:00
commit 09dea46948
107 changed files with 11564 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
shine/.gitignore vendored Normal file
View File

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

10
shine/.idea/.gitignore generated vendored Normal file
View File

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

8
shine/.idea/modules.xml generated Normal file
View File

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

12
shine/.idea/shine.iml generated Normal file
View File

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

6
shine/.idea/vcs.xml generated Normal file
View File

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

7
shine/.prettierignore Normal file
View File

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

9
shine/AGENTS.md Normal file
View File

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

39
shine/Anchor.toml Normal file
View File

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

3027
shine/Cargo.lock generated Normal file
View File

File diff suppressed because it is too large Load Diff

25
shine/Cargo.toml Normal file
View File

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

31
shine/doc/Deploy.txt Normal file
View File

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

39
shine/doc/READ_ME.txt Normal file
View File

@ -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 имя_проекта

65
shine/doc/READ_ME_NEW_DEPLOY.txt Normal file
View File

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

1
shine/doc/ReadMe.md Normal file
View File

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

144
shine/doc/SHINE_USER_PDA_V1.md Normal file
View File

@ -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 запрещено.

7
shine/doc/TODO Normal file
View File

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

19
shine/doc/how to getback money after deploy from buffer.txt Normal file
View File

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

6
shine/doc/how todo minimal size.txt Normal file
View File

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

44
shine/doc/sh/restart.sh Executable file
View File

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

23
shine/doc/sh/stop.sh Executable file
View File

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

145
shine/doc/что содержит utils.txt Normal file
View File

@ -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 в любой ситуации

12
shine/migrations/deploy.ts Normal file
View File

@ -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.
};

29
shine/mu.sh Executable file
View File

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

20
shine/package.json Normal file
View File

@ -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"
}
}

10
shine/programs/common/Cargo.toml Normal file
View File

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

1
shine/programs/common/src/lib.rs Normal file
View File

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

402
shine/programs/common/src/utils.rs Normal file
View File

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

33
shine/programs/shine_payments/Cargo.toml Normal file
View File

@ -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"]

30
shine/programs/shine_payments/dApp/copyToServer.sh Executable file
View File

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

404
shine/programs/shine_payments/dApp/init.html Normal file
View File

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

326
shine/programs/shine_payments/src/investments.rs Normal file
View File

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

158
shine/programs/shine_payments/src/lib.rs Normal file
View File

@ -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>,
}

190
shine/programs/shine_payments/src/nft.rs Normal file
View File

@ -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,
}

30
shine/programs/shine_users/Cargo.toml Normal file
View File

@ -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"]

23
shine/programs/shine_users/src/lib.rs Normal file
View File

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

12
shine/programs/shine_users/src/settings.rs Normal file
View File

@ -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;

592
shine/programs/shine_users/src/users.rs Normal file
View File

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

76
shine/scripts/devnet/README.md Normal file
View File

@ -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 уже инициализирован.

285
shine/scripts/devnet/quick_devnet_e2e.js Normal file
View File

@ -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);
});

205
shine/scripts/devnet/quick_devnet_e2e_multi.js Normal file
View File

@ -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);
});

16
shine/tests/shine.ts Normal file
View File

@ -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);
});
});

10
shine/tsconfig.json Normal file
View File

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

3
shine/validator.log Normal file
View File

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

1144
shine/yarn.lock Normal file
View File

File diff suppressed because it is too large Load Diff

42
solana-shine-client-lib/.gitignore vendored Normal file
View File

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

10
solana-shine-client-lib/.idea/.gitignore generated vendored Normal file
View File

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

18
solana-shine-client-lib/.idea/gradle.xml generated Normal file
View File

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

10
solana-shine-client-lib/.idea/misc.xml generated Normal file
View File

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

6
solana-shine-client-lib/.idea/vcs.xml generated Normal file
View File

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

46
solana-shine-client-lib/build.gradle Normal file
View File

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

BIN
solana-shine-client-lib/gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

6
solana-shine-client-lib/gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

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

234
solana-shine-client-lib/gradlew vendored Executable file
View File

@ -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" "$@"

89
solana-shine-client-lib/gradlew.bat vendored Normal file
View File

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

BIN
solana-shine-client-lib/libs/tmp/solanaj-1.20.4.jar Normal file
View File

Binary file not shown.

2
solana-shine-client-lib/settings.gradle Normal file
View File

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

56
solana-shine-client-lib/solana-shine-lib/build.gradle Normal file
View File

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

BIN
solana-shine-client-lib/solana-shine-lib/libs/solanaj-1.20.4.jar Normal file
View File

Binary file not shown.

9
solana-shine-client-lib/solana-shine-lib/src/main/java/TODO.txt Normal file
View File

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

42
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaSettings.java Normal file
View File

@ -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;
}
}

218
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaTxWatcher.java Normal file
View File

@ -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());
}
}

88
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/SolanaWrapper.java Normal file
View File

@ -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);
}
}

19
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/actions.md Normal file
View File

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

76
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/config/Const.java Normal file
View File

@ -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);
}
}

35
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/ExeptionList.txt Normal file
View File

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

43
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaErrorHandler.java Normal file
View File

@ -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);
}
}

13
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException.java Normal file
View File

@ -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);
}
}

41
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_InProgram.java Normal file
View File

@ -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;
}
}
}

12
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_IncorrectProgramId.java Normal file
View File

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

10
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_InsufficientFundsForFee.java Normal file
View File

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

21
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_LibLogic.java Normal file
View File

@ -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 "";
}
}

8
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_RpcConnection.java Normal file
View File

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

14
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/exceptions/SolanaException_UserNotFound.java Normal file
View File

@ -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);
}
}

98
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/InitializeUserCounter/InitializeUserCounter.java Normal file
View File

@ -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);
}
}

104
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/RegisterUser/RegisterUserStepOne.java Normal file
View File

@ -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);
}
}

156
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/callSolanaFunc/RegisterUser/RegisterUserWithOneDev.java Normal file
View File

@ -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
);
}
}

103
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userById/UserByIdParser.java Normal file
View File

@ -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;
}
}

48
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userById/UserByIdReader.java Normal file
View File

@ -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();
}
}
}

73
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userByLogin/UserByLoginParser.java Normal file
View File

@ -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;
}
}

58
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userByLogin/UserByLoginReader.java Normal file
View File

@ -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();
}
}
}

60
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/readFromSolana/userCounter/UserCounterReader.java Normal file
View File

@ -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();
}
}
}

68
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/airDrops/SolanaAirdrop.java Normal file
View File

@ -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);
}
}

72
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/balanse/SolanaBalanceChecker.java Normal file
View File

@ -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;
// }
}
}

26
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/keysGenerator/KeyPairBase58.java Normal file
View File

@ -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" +
'}';
}
}

101
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/keysGenerator/SolanaKeyGeneratorManual.java Normal file
View File

@ -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();
}
}
}

73
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/standartActions/transfer/SolanaTransfer.java Normal file
View File

@ -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());
}
}
}

55
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/KeyPair.java Normal file
View File

@ -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;
}
}

39
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/KeyUtils.java Normal file
View File

@ -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;
}
}

378
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/SolanaProgramCaller.java Normal file
View File

@ -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);
}
}
}

86
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/SolanaRpcClient.java Normal file
View File

@ -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());
}
}
}

19
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/jsonrpc/JsonRpcRequest.java Normal file
View File

@ -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;
}
}

157
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/reader/PdaReader.java Normal file
View File

@ -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));
}
}
}

29
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/ResultChecker.java Normal file
View File

@ -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");
}
}
}

210
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/SolanaTransactionStatusChecker.java Normal file
View File

@ -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;
}
}

68
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/TransactionStatusChecker.java Normal file
View File

@ -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;
}
}

126
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/internal/utils/resultChecker/TransactionStatusHelper.java Normal file
View File

@ -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);
}
}

22
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/TxStatus.java Normal file
View File

@ -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 // Не удаётся подключиться по сете
}

52
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/UserById.java Normal file
View File

@ -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 +
'}';
}
}

23
solana-shine-client-lib/solana-shine-lib/src/main/java/me/shineup/solana/model/UserByLogin.java Normal file
View File

@ -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 +
'}';
}
}

2
solana-shine-client-lib/src/main/Build.txt Normal file
View File

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

Some files were not shown because too many files have changed in this diff Show More