Улучшить UI регистрации и связанные сценарии

This commit is contained in:
AidarKC
2026-11-08 18:04:06 +03:00
parent 9405f28525
commit 4068465ee6
66 changed files with 842 additions and 221 deletions
@@ -46,6 +46,8 @@ const IX_CREATE_USER_PDA: u8 = 3;
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 NAMESPACE_CURRENCY_SOL: u8 = 1; // 2 зарезервировано под USDT, пока запрещено
const CERTIFICATE_DOMAIN: &[u8] = b"SHiNE_FREE_REG_V1\0";
#[repr(u32)]
@@ -95,6 +97,8 @@ enum ShineUsersError {
InvalidUpgradeAuthority = 42,
NamespaceAlreadyExists = 43,
CertificateRequired = 44,
RegistrationFeeBelowRent = 45,
UnsupportedNamespaceCurrency = 46,
}
impl From<ShineUsersError> for ProgramError {
@@ -208,6 +212,7 @@ pub struct NamespaceState {
pub min_localpart_len: u8,
pub namespace: String,
pub registration_fee: u64,
pub currency_code: u8,
pub registrar_pubkey: Option<Pubkey>,
pub server_login: Option<String>,
}
@@ -297,6 +302,13 @@ fn process_instruction<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'a>],
r.finish()?;
process_create_namespace(program_id, accounts, args)
},
IX_UPDATE_NAMESPACE_PRICE => {
let namespace_name = r.read_string_u8()?;
let currency_code = r.read_u8()?;
let registration_fee = r.read_u64()?;
r.finish()?;
process_update_namespace_price(program_id, accounts, &namespace_name, currency_code, registration_fee)
},
IX_CLOSE_LEGACY_USER_PDA => dispatch_close_legacy_user_pda(program_id, accounts, r),
_ => Err(ProgramError::from(ShineUsersError::InvalidInstruction)),
}
@@ -324,7 +336,7 @@ fn parse_namespace_args(r: &mut Reader<'_>) -> Result<NamespaceState, ProgramErr
2 => (Some(r.read_pubkey()?), Some(r.read_string_u8()?)),
_ => return Err(ShineUsersError::InvalidNamespace.into()),
};
let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, registrar_pubkey, server_login };
let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, currency_code: NAMESPACE_CURRENCY_SOL, registrar_pubkey, server_login };
validate_namespace_state(&state)?;
Ok(state)
}
@@ -496,6 +508,35 @@ fn process_create_namespace(program_id: &Pubkey, accounts: &[AccountInfo], state
write_pda_exact(namespace_pda, &data)
}
/// Обновление цены namespace; единственный разрешённый администратор — текущая upgrade authority.
/// Мета economy PDA нужна для истории синхронизации; аккаунт только для чтения.
fn process_update_namespace_price(program_id: &Pubkey, accounts: &[AccountInfo], name: &str, currency_code: u8, registration_fee: u64) -> ProgramResult {
let mut it = accounts.iter();
let signer = next_account_info(&mut it)?;
let namespace_pda = next_account_info(&mut it)?;
let system_program_ai = next_account_info(&mut it)?;
let economy_pda = next_account_info(&mut it)?;
let program_ai = next_account_info(&mut it)?;
let programdata_ai = next_account_info(&mut it)?;
require!(it.next().is_none(), ShineUsersError::InvalidInstruction);
require!(signer.is_signer && signer.is_writable, ShineUsersError::InvalidSigner);
require!(namespace_pda.is_writable, ShineUsersError::InvalidAccountData);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_upgrade_authority(program_id, signer, program_ai, programdata_ai)?;
validate_users_economy_config_pda(program_id, economy_pda)?;
read_users_economy_config(economy_pda)?;
require!(!economy_pda.is_writable, ShineUsersError::InvalidAccountData);
validate_namespace_name(name)?;
let mut state = read_namespace(program_id, namespace_pda, name)?;
state.currency_code = currency_code;
state.registration_fee = registration_fee;
validate_namespace_state(&state)?;
let encoded = serialize_namespace(&state);
// v1.0 аккаунт создан без места под currency_code. При первом update расширяем на 1 байт.
ensure_pda_size_and_rent(namespace_pda, signer, system_program_ai, encoded.len())?;
write_pda_exact(namespace_pda, &encoded)
}
/// Проверяем не просто подписанта, а актуальную authority ProgramData ИМЕННО этой программы.
/// Bincode layout UpgradeableLoaderState: Program = [2:u32LE, programdata:32],
/// ProgramData = [3:u32LE, slot:u64LE, Option<Pubkey>:1+32].
@@ -586,6 +627,20 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
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)?;
// Цена namespace включает депозит PDA: пользователь оплачивает rent из своей
// фиксированной суммы, а в inflow_vault поступает лишь её остаток.
// Для заранее пополненного system-owned адреса учитываем только фактический top-up.
let required_rent = Rent::get()?.minimum_balance(settings::USER_PDA_SPACE);
// Недорогие namespace блокируются независимо от внешнего пополнения PDA:
// в любой момент цена должна покрывать rent записи фиксированного размера.
require!(namespace.registration_fee >= required_rent, ShineUsersError::RegistrationFeeBelowRent);
let rent_paid_by_signer = required_rent.saturating_sub(user_pda.lamports());
let namespace_remainder = namespace.registration_fee
.checked_sub(rent_paid_by_signer)
.ok_or(ProgramError::from(ShineUsersError::RegistrationFeeBelowRent))?;
let vault_fee = namespace_remainder
.checked_add(limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?)
.ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
create_pda_account(
signer,
user_pda,
@@ -596,8 +651,7 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
)?;
write_pda_exact(user_pda, &serialized)?;
let total_fee = namespace.registration_fee.checked_add(limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
transfer_lamports(signer, inflow_vault, system_program_ai, total_fee)?;
transfer_lamports(signer, inflow_vault, system_program_ai, vault_fee)?;
Ok(())
}
@@ -1091,6 +1145,7 @@ fn validate_full_login(login: &str) -> Result<&str, ProgramError> {
}
pub fn validate_namespace_state(state: &NamespaceState) -> ProgramResult {
require!(state.currency_code == NAMESPACE_CURRENCY_SOL, ShineUsersError::UnsupportedNamespaceCurrency);
validate_namespace_name(&state.namespace)?;
require!(state.namespace.len() + 1 + state.min_localpart_len as usize <= 30 && state.min_localpart_len > 0, ShineUsersError::InvalidNamespace);
match state.namespace_type {
@@ -1105,9 +1160,10 @@ pub fn validate_namespace_state(state: &NamespaceState) -> ProgramResult {
}
pub fn serialize_namespace(state: &NamespaceState) -> Vec<u8> {
let mut out = vec![1, 0, state.namespace_type, state.min_localpart_len, state.namespace.len() as u8];
let mut out = vec![1, 1, state.namespace_type, state.min_localpart_len, state.namespace.len() as u8];
out.extend_from_slice(state.namespace.as_bytes());
out.extend_from_slice(&state.registration_fee.to_le_bytes());
out.push(state.currency_code);
if let (Some(registrar), Some(server)) = (state.registrar_pubkey, state.server_login.as_ref()) {
out.extend_from_slice(registrar.as_ref());
out.push(server.len() as u8);
@@ -1122,18 +1178,21 @@ fn read_namespace(program_id: &Pubkey, ai: &AccountInfo, name: &str) -> Result<N
require!(ai.owner == program_id, ShineUsersError::InvalidAccountOwner);
let data = ai.try_borrow_data()?;
let mut r = Reader::new(&data);
require!(r.read_u8()? == 1 && r.read_u8()? == 0, ShineUsersError::InvalidNamespace);
require!(r.read_u8()? == 1, ShineUsersError::InvalidNamespace);
let minor = r.read_u8()?;
require!(minor == 0 || minor == 1, ShineUsersError::InvalidNamespace);
let namespace_type = r.read_u8()?;
let min_localpart_len = r.read_u8()?;
let namespace = r.read_string_u8()?;
let registration_fee = r.read_u64()?;
let currency_code = if minor == 1 { r.read_u8()? } else { NAMESPACE_CURRENCY_SOL };
let (registrar_pubkey, server_login) = match namespace_type {
1 => (None, None),
2 => (Some(r.read_pubkey()?), Some(r.read_string_u8()?)),
_ => return Err(ShineUsersError::InvalidNamespace.into()),
};
r.finish()?;
let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, registrar_pubkey, server_login };
let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, currency_code, registrar_pubkey, server_login };
require!(state.namespace == name, ShineUsersError::InvalidNamespace);
validate_namespace_state(&state)?;
Ok(state)