SHA256
Добавить систему поддержки SHiNE
This commit is contained in:
@@ -194,3 +194,20 @@ Legacy migration в 1.2 отсутствует. После удаления те
|
||||
|
||||
### Регистронезависимая идентичность (28.10.2026)
|
||||
Локальная часть полного `login@namespace` допускает латинские буквы `A–Z` и `a–z`, цифры и `_`; `namespace` допускает только нижний ASCII-регистр. Выбранный при регистрации регистр логина неизменяем. Адрес user PDA вычисляется по `SHA256(UTF8("user_login=" + ASCII-lowercase(fullLogin)))` и bump для `find_program_address`. Сама запись PDA 1.2 содержит **оригинальное** написание `login`; подписи записи и регистраторского сертификата проверяются по исходному регистру без нормализации. Это изменение правила seed, не бинарного формата PDA.
|
||||
# Блок статистики поддержки
|
||||
|
||||
После `record_len` байтов основной подписанной записи располагается необязательный
|
||||
неподписанный блок `SupportStats`. Он **не входит** в `record_len` и не участвует
|
||||
в хеше или цифровой подписи `UserRecordV12`.
|
||||
|
||||
| Смещение | Поле | Формат |
|
||||
| --- | --- | --- |
|
||||
| 0 | version | `u8` (`1`) |
|
||||
| 1 | support_sent | `u64 LE` |
|
||||
| 9 | support_received | `u64 LE` |
|
||||
| 17 | dao_direct | `u64 LE` |
|
||||
|
||||
Полный размер v1 — 25 байт. Если за `record_len` нет байтов либо первый байт
|
||||
равен `0`, это v0 и все значения равны нулю. Неизвестная версия или неполный
|
||||
v1 являются повреждённым форматом. Программа вправе обновлять этот блок без
|
||||
пользовательской подписи; при update старой записи v0 он создаётся автоматически.
|
||||
|
||||
@@ -184,3 +184,21 @@ forks[]:
|
||||
Accounts: signer/current upgrade authority writable, namespace PDA writable, system program read-only, economy PDA read-only, `shine_users` executable read-only, ProgramData read-only. Проверяется реальная текущая upgrade authority, а не ключ по умолчанию. У старого namespace 1.0 цена обновляется с миграцией бинарной записи до v1.1 и возможной доплатой rent за 1 байт. Изменение полей registrar/server/type не допускается.
|
||||
|
||||
Синхронизатор получает новую цену по истории economy PDA с разбором opcode 8 и чтением обновлённого namespace PDA. Новые регистрации в обоих сценариях всегда проверяют стоимость по on-chain namespace непосредственно перед отправкой транзакции.
|
||||
# Поддержка и комиссия обновления
|
||||
|
||||
`update_user_pda` после успешной проверки и записи взимает фиксированные
|
||||
`20_000` lamports в существующий `shine_payments_inflow_vault`, дополнительно к
|
||||
оплате увеличения лимита и rent. Ошибка инструкции откатывает и запись, и перевод.
|
||||
|
||||
Инструкция `9` (`support_user`) принимает sender/recipient login, `u64 LE`
|
||||
сумму, target (`USER=0`, `CHANNEL=1`, `MESSAGE=2`) и соответствующие бинарные
|
||||
идентификаторы блоков/хешей. Сумма положительна и кратна 10; 90% переводится
|
||||
актуальному blockchain-key получателя, 10% — только в inflow vault. Отправитель
|
||||
и получатель обязаны быть разными paid PDA с актуальными ключами. В транзакции
|
||||
read-only присутствует economy PDA для индексирования. Обновляются
|
||||
`support_sent` и `support_received`.
|
||||
|
||||
Инструкция `10` (`support_dao`) принимает login и положительную сумму, переводит
|
||||
100% в тот же inflow vault и увеличивает `dao_direct`. Она также требует paid PDA,
|
||||
актуальный blockchain key и read-only economy PDA. Ни одна из инструкций не
|
||||
переводит средства непосредственно в `dao_wallet`.
|
||||
|
||||
@@ -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 });
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,3 +21,5 @@ pub const LIMIT_STEP: u64 = 10_000;
|
||||
pub const START_LAMPORTS_PER_LIMIT_STEP: u64 = 100_000;
|
||||
/// Стартовый бонус лимита.
|
||||
pub const START_BONUS_LIMIT: u64 = 100_000;
|
||||
/// Обязательная комиссия за каждое успешно завершённое обновление user PDA.
|
||||
pub const UPDATE_FEE_LAMPORTS: u64 = 20_000;
|
||||
|
||||
Reference in New Issue
Block a user