Добавить систему поддержки SHiNE

This commit is contained in:
AidarKC
2026-11-12 11:01:31 +03:00
parent 6b120731a3
commit c97df82538
34 changed files with 1323 additions and 52 deletions
@@ -47,6 +47,13 @@ const IX_UPDATE_USER_PDA: u8 = 4;
const IX_CLOSE_LEGACY_USER_PDA: u8 = 6;
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_LEN: usize = 25;
const SUPPORT_TARGET_USER: u8 = 0;
const SUPPORT_TARGET_CHANNEL: u8 = 1;
const SUPPORT_TARGET_MESSAGE: u8 = 2;
const NAMESPACE_CURRENCY_SOL: u8 = 1; // 2 зарезервировано под USDT, пока запрещено
const CERTIFICATE_DOMAIN: &[u8] = b"SHiNE_FREE_REG_V1\0";
@@ -99,6 +106,8 @@ enum ShineUsersError {
CertificateRequired = 44,
RegistrationFeeBelowRent = 45,
UnsupportedNamespaceCurrency = 46,
InvalidSupport = 47,
UnsupportedSupportStats = 48,
}
impl From<ShineUsersError> for ProgramError {
@@ -152,6 +161,29 @@ pub struct UserRecordV12 {
pub signature: [u8; 64],
}
/// Блок располагается сразу после подписанной записи и не входит в record_len.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct SupportStats {
pub support_sent: u64,
pub support_received: u64,
pub dao_direct: u64,
}
#[derive(Clone, Debug)]
struct SupportUserArgs {
sender_login: String,
recipient_login: String,
amount_lamports: u64,
target_type: u8,
channel_block_number: Option<u64>,
channel_block_hash: Option<[u8; 32]>,
message_block_number: Option<u64>,
message_block_hash: Option<[u8; 32]>,
}
#[derive(Clone, Debug)]
struct SupportDaoArgs { sender_login: String, amount_lamports: u64 }
impl UserRecordV12 {
fn active_fork(&self) -> Result<&ForkRecordV12, ProgramError> {
self.forks.last().ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))
@@ -297,6 +329,8 @@ fn process_instruction<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>],
}
IX_CREATE_USER_PDA => dispatch_create_user_pda(program_id, accounts, r),
IX_UPDATE_USER_PDA => dispatch_update_user_pda(program_id, accounts, r),
IX_SUPPORT_USER => dispatch_support_user(program_id, accounts, r),
IX_SUPPORT_DAO => dispatch_support_dao(program_id, accounts, r),
IX_CREATE_NAMESPACE => {
let args = parse_namespace_args(&mut r)?;
r.finish()?;
@@ -314,6 +348,27 @@ fn process_instruction<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>],
}
}
fn dispatch_support_user(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult {
let sender_login = r.read_string_u8()?;
let recipient_login = r.read_string_u8()?;
let amount_lamports = 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),
SUPPORT_TARGET_CHANNEL => (Some(r.read_u64()?), Some(r.read_fixed_32()?), None, None),
SUPPORT_TARGET_MESSAGE => (Some(r.read_u64()?), Some(r.read_fixed_32()?), Some(r.read_u64()?), Some(r.read_fixed_32()?)),
_ => 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 })
}
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()? };
r.finish()?;
process_support_dao(program_id, accounts, args)
}
fn dispatch_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>], mut r: Reader<'_>) -> ProgramResult {
let args = Box::new(parse_create_args(&mut r)?);
r.finish()?;
@@ -626,7 +681,8 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
verify_ed25519_instruction_pubkey_message(instructions_sysvar, -2, &record.root_key, unsigned_hash.as_ref())?;
record.signature = verify_record_signature_hash_at(instructions_sysvar, -1, &record.active_fork()?.blockchain_key, &args.signature, unsigned_hash.as_ref())?;
let serialized = pad_to_fixed_size(serialize_full_record_v12(&record)?, settings::USER_PDA_SPACE)?;
let serialized = serialize_record_with_stats(&record, SupportStats::default())?;
let serialized = pad_to_fixed_size(serialized, settings::USER_PDA_SPACE)?;
// Цена namespace включает депозит PDA: пользователь оплачивает rent из своей
// фиксированной суммы, а в inflow_vault поступает лишь её остаток.
// Для заранее пополненного system-owned адреса учитываем только фактический top-up.
@@ -759,17 +815,100 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args:
verify_ed25519_instruction_pubkey_message(instructions_sysvar, -2, &old_authority, unsigned_hash.as_ref())?;
new_record.signature = verify_record_signature_hash_at(instructions_sysvar, -1, &record_signer, &args.signature, unsigned_hash.as_ref())?;
let serialized = serialize_full_record_v12(&new_record)?;
let stats = read_support_stats(&raw)?;
let serialized = serialize_record_with_stats(&new_record, stats)?;
ensure_pda_size_and_rent(user_pda, signer, system_program_ai, serialized.len())?;
write_pda_exact(user_pda, &serialized)?;
let topup_fee = limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?;
if topup_fee > 0 {
transfer_lamports(signer, inflow_vault, system_program_ai, topup_fee)?;
}
let total_fee = topup_fee.checked_add(settings::UPDATE_FEE_LAMPORTS).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
transfer_lamports(signer, inflow_vault, system_program_ai, total_fee)?;
Ok(())
}
/// Accounts: signer(sender wallet), sender PDA, recipient wallet, recipient PDA,
/// inflow vault, economy config (readonly), system program. Экономический PDA
/// намеренно присутствует в каждой операции для индексирования истории.
fn process_support_user(program_id: &Pubkey, accounts: &[AccountInfo], args: SupportUserArgs) -> ProgramResult {
let mut it = accounts.iter();
let sender = next_account_info(&mut it)?;
let sender_pda = next_account_info(&mut it)?;
let recipient = next_account_info(&mut it)?;
let recipient_pda = next_account_info(&mut it)?;
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)?;
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);
validate_inflow_vault(inflow_vault)?;
validate_users_economy_config_pda(program_id, economy_config)?;
require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData);
require_keys_eq!(find_user_pda(program_id, &args.sender_login).0, *sender_pda.key, ShineUsersError::InvalidPdaAddress);
require_keys_eq!(find_user_pda(program_id, &args.recipient_login).0, *recipient_pda.key, ShineUsersError::InvalidPdaAddress);
require!(sender_pda.owner == program_id && recipient_pda.owner == program_id, ShineUsersError::InvalidAccountOwner);
let sender_raw = read_pda_all(sender_pda)?;
let recipient_raw = read_pda_all(recipient_pda)?;
require!(record_format_minor(&sender_raw)? == FORMAT_MINOR && record_format_minor(&recipient_raw)? == FORMAT_MINOR, ShineUsersError::InvalidRecordFormat);
let sender_record = deserialize_record_v12_from_pda(&sender_raw)?;
let recipient_record = deserialize_record_v12_from_pda(&recipient_raw)?;
require!(sender_record.login == args.sender_login && recipient_record.login == args.recipient_login, ShineUsersError::InvalidRecordData);
let sender_key = sender_record.active_fork()?.blockchain_key;
let recipient_key = recipient_record.active_fork()?.blockchain_key;
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 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))?;
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())?;
ensure_pda_size_and_rent(recipient_pda, sender, system_program_ai, recipient_data.len())?;
transfer_lamports(sender, recipient, system_program_ai, recipient_amount)?;
transfer_lamports(sender, inflow_vault, system_program_ai, inflow_amount)?;
write_pda_exact(sender_pda, &sender_data)?;
write_pda_exact(recipient_pda, &recipient_data)?;
Ok(())
}
/// Accounts: signer, sender PDA, inflow vault, economy config (readonly), system.
fn process_support_dao(program_id: &Pubkey, accounts: &[AccountInfo], args: SupportDaoArgs) -> ProgramResult {
let mut it = accounts.iter();
let sender = next_account_info(&mut it)?;
let sender_pda = next_account_info(&mut it)?;
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)?;
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);
validate_inflow_vault(inflow_vault)?;
validate_users_economy_config_pda(program_id, economy_config)?;
require!(!economy_config.is_writable, ShineUsersError::InvalidAccountData);
require_keys_eq!(find_user_pda(program_id, &args.sender_login).0, *sender_pda.key, ShineUsersError::InvalidPdaAddress);
require!(sender_pda.owner == program_id, ShineUsersError::InvalidAccountOwner);
let raw = read_pda_all(sender_pda)?;
require!(record_format_minor(&raw)? == FORMAT_MINOR, ShineUsersError::InvalidRecordFormat);
let record = deserialize_record_v12_from_pda(&raw)?;
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))?;
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)
}
fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args: CloseLegacyUserPdaArgs) -> ProgramResult {
let mut it = accounts.iter();
let caller = next_account_info(&mut it)?;
@@ -1023,6 +1162,30 @@ fn serialize_full_record_v12(record: &UserRecordV12) -> Result<Vec<u8>, ProgramE
Ok(out)
}
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()); }
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);
let mut cursor = record_len + 1;
Ok(SupportStats {
support_sent: read_u64_from(raw, &mut cursor)?,
support_received: read_u64_from(raw, &mut cursor)?,
dao_direct: read_u64_from(raw, &mut cursor)?,
})
}
fn serialize_record_with_stats(record: &UserRecordV12, stats: SupportStats) -> Result<Vec<u8>, ProgramError> {
let mut out = serialize_full_record_v12(record)?;
out.push(SUPPORT_STATS_VERSION);
out.extend_from_slice(&stats.support_sent.to_le_bytes());
out.extend_from_slice(&stats.support_received.to_le_bytes());
out.extend_from_slice(&stats.dao_direct.to_le_bytes());
Ok(out)
}
fn hash_unsigned_record_v12(record: &UserRecordV12) -> Result<[u8; 32], ProgramError> {
let unsigned = serialize_unsigned_record_v12(record)?;
let digest = hashv(&[&unsigned]);
@@ -1317,6 +1480,9 @@ fn limit_fee_lamports(limit_delta: u64, lamports_per_limit_step: u64) -> Result<
fn pad_to_fixed_size(mut bytes: Vec<u8>, target_size: usize) -> Result<Vec<u8>, ProgramError> { require!(bytes.len() <= target_size, ShineUsersError::RecordTooLarge); bytes.resize(target_size, 0); Ok(bytes) }
fn read_pda_all(pda: &AccountInfo) -> Result<Vec<u8>, ProgramError> { Ok(pda.try_borrow_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?.to_vec()) }
/// Запись пользовательского PDA всегда идёт вместе со статистикой. Хвост очищается
/// только после уже записанного статистического блока, поэтому смена длины записи
/// не может уничтожить SupportStats.
fn write_pda_exact(pda: &AccountInfo, data: &[u8]) -> ProgramResult { let mut dst = pda.try_borrow_mut_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?; require!(data.len() <= dst.len(), ShineUsersError::RecordTooLarge); dst[..data.len()].copy_from_slice(data); for b in &mut dst[data.len()..] { *b = 0; } Ok(()) }
fn write_pda_prefix(pda: &AccountInfo, data: &[u8]) -> ProgramResult { let mut dst = pda.try_borrow_mut_data().map_err(|_| ProgramError::from(ShineUsersError::InvalidAccountData))?; require!(data.len() <= dst.len(), ShineUsersError::RecordTooLarge); dst[..data.len()].copy_from_slice(data); Ok(()) }
@@ -1327,3 +1493,24 @@ fn read_u64_from(data: &[u8], cursor: &mut usize) -> Result<u64, ProgramError> {
fn read_fixed_32_from(data: &[u8], cursor: &mut usize) -> Result<[u8; 32], ProgramError> { let end = cursor.checked_add(32).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; <[u8; 32]>::try_from(s).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) }
fn read_fixed_64_from(data: &[u8], cursor: &mut usize) -> Result<[u8; 64], ProgramError> { let end = cursor.checked_add(64).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; <[u8; 64]>::try_from(s).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) }
fn read_len_prefixed_string_from(data: &[u8], cursor: &mut usize) -> Result<String, ProgramError> { let len = read_u8_from(data, cursor)? as usize; let end = cursor.checked_add(len).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; let s = data.get(*cursor..end).ok_or(ProgramError::from(ShineUsersError::InvalidRecordData))?; *cursor = end; std::str::from_utf8(s).map(|v| v.to_string()).map_err(|_| ProgramError::from(ShineUsersError::InvalidRecordData)) }
#[cfg(test)]
mod support_stats_tests {
use super::*;
#[test]
fn v0_and_v1_support_stats_are_read_without_touching_record_len() {
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());
let mut v1 = v0;
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.resize(105, 0);
v1[97..105].copy_from_slice(&7u64.to_le_bytes());
assert_eq!(read_support_stats(&v1).unwrap(), SupportStats { support_sent: 100, support_received: 90, dao_direct: 7 });
}
}