Перевести донаты на Stars и обновить Devnet

This commit is contained in:
AidarKC
2026-11-14 00:55:02 +03:00
parent c972a975fd
commit 97db033eb8
39 changed files with 1020 additions and 198 deletions
@@ -15,6 +15,8 @@ use solana_program::{
sysvar::{instructions::{load_current_index_checked, load_instruction_at_checked}, Sysvar},
};
use std::{convert::TryFrom, str::FromStr};
use anchor_lang::AccountDeserialize;
use pyth_solana_receiver_sdk::price_update::{get_feed_id_from_hex, PriceUpdateV2};
pub mod settings;
@@ -49,7 +51,7 @@ const IX_CREATE_NAMESPACE: u8 = 7;
const IX_UPDATE_NAMESPACE_PRICE: u8 = 8;
const IX_SUPPORT_USER: u8 = 9;
const IX_SUPPORT_DAO: u8 = 10;
const SUPPORT_STATS_VERSION: u8 = 1;
const SUPPORT_STATS_VERSION: u8 = 2; // ONLY Stars cents, old SOL stats rejected
const SUPPORT_STATS_LEN: usize = 25;
const SUPPORT_TARGET_USER: u8 = 0;
const SUPPORT_TARGET_CHANNEL: u8 = 1;
@@ -108,6 +110,10 @@ enum ShineUsersError {
UnsupportedNamespaceCurrency = 46,
InvalidSupport = 47,
UnsupportedSupportStats = 48,
InvalidStars = 49,
InvalidOracle = 50,
StaleOracle = 51,
StarRateMismatch = 52,
}
impl From<ShineUsersError> for ProgramError {
@@ -174,6 +180,7 @@ struct SupportUserArgs {
sender_login: String,
recipient_login: String,
amount_lamports: u64,
amount_star_cents: u64,
target_type: u8,
channel_block_number: Option<u64>,
channel_block_hash: Option<[u8; 32]>,
@@ -182,7 +189,7 @@ struct SupportUserArgs {
}
#[derive(Clone, Debug)]
struct SupportDaoArgs { sender_login: String, amount_lamports: u64 }
struct SupportDaoArgs { sender_login: String, amount_lamports: u64, amount_star_cents: u64 }
impl UserRecordV12 {
fn active_fork(&self) -> Result<&ForkRecordV12, ProgramError> {
@@ -352,6 +359,7 @@ fn dispatch_support_user(program_id: &Pubkey, accounts: &[AccountInfo], mut r: R
let sender_login = r.read_string_u8()?;
let recipient_login = r.read_string_u8()?;
let amount_lamports = r.read_u64()?;
let amount_star_cents = r.read_u64()?;
let target_type = r.read_u8()?;
let (channel_block_number, channel_block_hash, message_block_number, message_block_hash) = match target_type {
SUPPORT_TARGET_USER => (None, None, None, None),
@@ -360,11 +368,11 @@ fn dispatch_support_user(program_id: &Pubkey, accounts: &[AccountInfo], mut r: R
_ => return Err(ShineUsersError::InvalidSupport.into()),
};
r.finish()?;
process_support_user(program_id, accounts, SupportUserArgs { sender_login, recipient_login, amount_lamports, target_type, channel_block_number, channel_block_hash, message_block_number, message_block_hash })
process_support_user(program_id, accounts, SupportUserArgs { sender_login, recipient_login, amount_lamports, amount_star_cents, target_type, channel_block_number, channel_block_hash, message_block_number, message_block_hash })
}
fn dispatch_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult {
let args = SupportDaoArgs { sender_login: r.read_string_u8()?, amount_lamports: r.read_u64()? };
let args = SupportDaoArgs { sender_login: r.read_string_u8()?, amount_lamports: r.read_u64()?, amount_star_cents: r.read_u64()? };
r.finish()?;
process_support_dao(program_id, accounts, args)
}
@@ -829,6 +837,55 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args:
/// Accounts: signer(sender wallet), sender PDA, recipient wallet, recipient PDA,
/// inflow vault, economy config (readonly), system program. Экономический PDA
/// намеренно присутствует в каждой операции для индексирования истории.
// SHiNE Stars v1: 1 Star = 1 USDT reference unit. Both prices are full-verification
// Pyth price-update accounts. No client-provided price is trusted.
const PYTH_SOL_FEED: &str = "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d";
const PYTH_USDT_FEED: &str = "0x2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b";
// Devnet допускает более редкие обновления Pyth; production-лимит должен быть строже.
const ORACLE_MAX_AGE_SECONDS: u64 = 3_600;
const ORACLE_CONFIDENCE_MAX_PPM: u128 = 10_000; // 1%, reject weak feeds
fn verified_pyth_price(account: &AccountInfo, feed: &str) -> Result<u128, ProgramError> {
require_keys_eq!(*account.owner, pyth_solana_receiver_sdk::ID, ShineUsersError::InvalidOracle);
let raw = account.try_borrow_data()?;
let mut bytes: &[u8] = &raw;
let update = PriceUpdateV2::try_deserialize(&mut bytes)
.map_err(|_| ProgramError::from(ShineUsersError::InvalidOracle))?;
let feed_id = get_feed_id_from_hex(feed).map_err(|_| ProgramError::from(ShineUsersError::InvalidOracle))?;
let price = update.get_price_no_older_than(&Clock::get()?, ORACLE_MAX_AGE_SECONDS, &feed_id)
.map_err(|_| ProgramError::from(ShineUsersError::StaleOracle))?;
require!(price.price > 0, ShineUsersError::InvalidOracle);
let p = price.price as u128;
require!((price.conf as u128).checked_mul(1_000_000).ok_or(ShineUsersError::MathOverflow)?
<= p.checked_mul(ORACLE_CONFIDENCE_MAX_PPM).ok_or(ShineUsersError::MathOverflow)?, ShineUsersError::InvalidOracle);
// Normalize to price * 10^8 without floating point.
let power = i64::from(price.exponent) + 8;
require!((-18..=18).contains(&power), ShineUsersError::InvalidOracle);
let normalized = if power >= 0 {
p.checked_mul(10u128.pow(power as u32))
} else {
Some(p / 10u128.pow((-power) as u32))
}.ok_or(ShineUsersError::MathOverflow)?;
require!(normalized > 0, ShineUsersError::InvalidOracle);
Ok(normalized)
}
fn verify_stars_quote(lamports: u64, star_cents: u64, sol_oracle: &AccountInfo, usdt_oracle: &AccountInfo) -> ProgramResult {
require!(star_cents >= 10 && lamports > 0, ShineUsersError::InvalidStars);
let sol_usd = verified_pyth_price(sol_oracle, PYTH_SOL_FEED)?;
let usdt_usd = verified_pyth_price(usdt_oracle, PYTH_USDT_FEED)?;
let actual_num = (lamports as u128).checked_mul(sol_usd).and_then(|v| v.checked_mul(100))
.ok_or(ShineUsersError::MathOverflow)?;
let den = 1_000_000_000u128.checked_mul(usdt_usd).ok_or(ShineUsersError::MathOverflow)?;
let declared_num = (star_cents as u128).checked_mul(den).ok_or(ShineUsersError::MathOverflow)?;
let difference = actual_num.abs_diff(declared_num);
// |actual - declared| / declared <= 0.005. Avoid intermediate overflow.
require!(difference.checked_mul(200).ok_or(ShineUsersError::MathOverflow)? <= declared_num,
ShineUsersError::StarRateMismatch);
Ok(())
}
fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: SupportUserArgs) -> ProgramResult {
let mut it = accounts.iter();
let sender = next_account_info(&mut it)?;
@@ -838,12 +895,15 @@ fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: Sup
let inflow_vault = next_account_info(&mut it)?;
let economy_config = next_account_info(&mut it)?;
let system_program_ai = next_account_info(&mut it)?;
let sol_oracle = next_account_info(&mut it)?;
let usdt_oracle = next_account_info(&mut it)?;
require!(it.next().is_none(), ShineUsersError::InvalidInstruction);
require!(sender.is_signer && sender.is_writable && recipient.is_writable && sender_pda.is_writable && recipient_pda.is_writable, ShineUsersError::InvalidSigner);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_full_login(&args.sender_login)?;
validate_full_login(&args.recipient_login)?;
require!(args.sender_login != args.recipient_login && args.amount_lamports > 0 && args.amount_lamports % 10 == 0, ShineUsersError::InvalidSupport);
require!(args.sender_login != args.recipient_login && args.amount_lamports > 0 && args.amount_star_cents >= 10, ShineUsersError::InvalidSupport);
verify_stars_quote(args.amount_lamports, args.amount_star_cents, sol_oracle, usdt_oracle)?;
validate_inflow_vault(inflow_vault)?;
validate_users_economy_config_pda(program_id, economy_config)?;
require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData);
@@ -861,12 +921,14 @@ fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: Sup
require_keys_eq!(sender_key, *sender.key, ShineUsersError::InvalidSigner);
require_keys_eq!(recipient_key, *recipient.key, ShineUsersError::InvalidSupport);
require!(sender_key != recipient_key, ShineUsersError::InvalidSupport);
let recipient_amount = args.amount_lamports.checked_mul(9).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?.checked_div(10).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
let inflow_amount = args.amount_lamports.checked_div(10).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
let inflow_amount = args.amount_lamports / 10 + u64::from(args.amount_lamports % 10 != 0);
let recipient_amount = args.amount_lamports - inflow_amount;
let dao_star_cents = args.amount_star_cents / 10 + u64::from(args.amount_star_cents % 10 != 0);
let author_star_cents = args.amount_star_cents - dao_star_cents;
let mut sender_stats = read_support_stats(&sender_raw)?;
let mut recipient_stats = read_support_stats(&recipient_raw)?;
sender_stats.support_sent = sender_stats.support_sent.checked_add(args.amount_lamports).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
recipient_stats.support_received = recipient_stats.support_received.checked_add(recipient_amount).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
sender_stats.support_sent = sender_stats.support_sent.checked_add(args.amount_star_cents).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
recipient_stats.support_received = recipient_stats.support_received.checked_add(author_star_cents).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
let sender_data = serialize_record_with_stats(&sender_record, sender_stats)?;
let recipient_data = serialize_record_with_stats(&recipient_record, recipient_stats)?;
ensure_pda_size_and_rent(sender_pda, sender, system_program_ai, sender_data.len())?;
@@ -875,6 +937,8 @@ fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: Sup
transfer_lamports(sender, inflow_vault, system_program_ai, inflow_amount)?;
write_pda_exact(sender_pda, &sender_data)?;
write_pda_exact(recipient_pda, &recipient_data)?;
solana_program::msg!("SHINE_STARS_V1|USER|{}|{}|{}|{}|{}|{}", args.sender_login, args.recipient_login,
args.amount_lamports, args.amount_star_cents, author_star_cents, dao_star_cents);
Ok(())
}
@@ -886,11 +950,14 @@ fn process_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], args: Supp
let inflow_vault = next_account_info(&mut it)?;
let economy_config = next_account_info(&mut it)?;
let system_program_ai = next_account_info(&mut it)?;
let sol_oracle = next_account_info(&mut it)?;
let usdt_oracle = next_account_info(&mut it)?;
require!(it.next().is_none(), ShineUsersError::InvalidInstruction);
require!(sender.is_signer && sender.is_writable && sender_pda.is_writable, ShineUsersError::InvalidSigner);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_full_login(&args.sender_login)?;
require!(args.amount_lamports > 0, ShineUsersError::InvalidSupport);
require!(args.amount_lamports > 0 && args.amount_star_cents >= 10, ShineUsersError::InvalidSupport);
verify_stars_quote(args.amount_lamports, args.amount_star_cents, sol_oracle, usdt_oracle)?;
validate_inflow_vault(inflow_vault)?;
validate_users_economy_config_pda(program_id, economy_config)?;
require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData);
@@ -902,11 +969,14 @@ fn process_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], args: Supp
require!(record.login == args.sender_login, ShineUsersError::InvalidRecordData);
require_keys_eq!(record.active_fork()?.blockchain_key, *sender.key, ShineUsersError::InvalidSigner);
let mut stats = read_support_stats(&raw)?;
stats.dao_direct = stats.dao_direct.checked_add(args.amount_lamports).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
stats.dao_direct = stats.dao_direct.checked_add(args.amount_star_cents).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
let data = serialize_record_with_stats(&record, stats)?;
ensure_pda_size_and_rent(sender_pda, sender, system_program_ai, data.len())?;
transfer_lamports(sender, inflow_vault, system_program_ai, args.amount_lamports)?;
write_pda_exact(sender_pda, &data)
write_pda_exact(sender_pda, &data)?;
solana_program::msg!("SHINE_STARS_V1|DAO|{}|-|{}|{}|0|{}", args.sender_login,
args.amount_lamports, args.amount_star_cents, args.amount_star_cents);
Ok(())
}
fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: CloseLegacyUserPdaArgs) -> ProgramResult {
@@ -1166,6 +1236,9 @@ fn read_support_stats(raw: &[u8]) -> Result<SupportStats, ProgramError> {
require!(raw.len() >= 9, ShineUsersError::InvalidRecordData);
let record_len = u16::from_le_bytes([raw[7], raw[8]]) as usize;
if record_len >= raw.len() || raw[record_len] == 0 { return Ok(SupportStats::default()); }
// Тестовый переход: прежние lamports-счётчики v1 намеренно забываются.
// При следующей записи PDA они заменяются нулевыми Stars v2.
if raw[record_len] == 1 { return Ok(SupportStats::default()); }
require!(raw[record_len] == SUPPORT_STATS_VERSION, ShineUsersError::UnsupportedSupportStats);
let end = record_len.checked_add(SUPPORT_STATS_LEN).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
require!(end <= raw.len(), ShineUsersError::InvalidRecordLength);
@@ -1499,7 +1572,7 @@ mod support_stats_tests {
use super::*;
#[test]
fn v0_and_v1_support_stats_are_read_without_touching_record_len() {
fn legacy_support_stats_are_reset_and_v2_is_supported() {
let mut v0 = vec![0u8; 100];
v0[7..9].copy_from_slice(&80u16.to_le_bytes());
assert_eq!(read_support_stats(&v0).unwrap(), SupportStats::default());
@@ -1507,10 +1580,12 @@ mod support_stats_tests {
v1[80] = 1;
v1[81..89].copy_from_slice(&100u64.to_le_bytes());
v1[89..97].copy_from_slice(&90u64.to_le_bytes());
// Отдельный полный буфер проверяет нормальный v1; укороченный v1 обязан отвергаться.
assert!(read_support_stats(&v1).is_err());
// Статистика v1 игнорируется: это lamports, не Stars.
assert_eq!(read_support_stats(&v1).unwrap(), SupportStats::default());
v1.resize(105, 0);
v1[97..105].copy_from_slice(&7u64.to_le_bytes());
assert_eq!(read_support_stats(&v1).unwrap(), SupportStats::default());
v1[80] = 2;
assert_eq!(read_support_stats(&v1).unwrap(), SupportStats { support_sent: 100, support_received: 90, dao_direct: 7 });
}
}