Регистрация V2: не проверено end-to-end

This commit is contained in:
AidarKC
2026-10-23 19:21:52 +03:00
parent 6c8159c5f7
commit cab26bbf41
95 changed files with 4469 additions and 1088 deletions
+206 -193
View File
@@ -3,9 +3,9 @@ use solana_program::{
clock::Clock,
entrypoint,
entrypoint::ProgramResult,
hash::hashv,
instruction::Instruction,
program::{get_return_data, invoke, invoke_signed},
hash::{hash, hashv},
bpf_loader_upgradeable,
program::{invoke, invoke_signed},
program_error::ProgramError,
program_memory::sol_memcmp,
pubkey::Pubkey,
@@ -44,9 +44,9 @@ const IX_INIT_USERS_ECONOMY_CONFIG: u8 = 1;
const IX_UPDATE_USERS_ECONOMY_CONFIG: u8 = 2;
const IX_CREATE_USER_PDA: u8 = 3;
const IX_UPDATE_USER_PDA: u8 = 4;
const IX_UPSERT_PROMO_SELLER: u8 = 5;
const IX_CLOSE_LEGACY_USER_PDA: u8 = 6;
const LOGIN_GUARD_IX_CLASSIFY_LOGIN: u8 = 1;
const IX_CREATE_NAMESPACE: u8 = 7;
const CERTIFICATE_DOMAIN: &[u8] = b"SHiNE_FREE_REG_V1\0";
#[repr(u32)]
#[derive(Clone, Copy, Debug)]
@@ -91,6 +91,10 @@ enum ShineUsersError {
RootChangeRequiresRoot = 38,
AmbiguousAuthorityRotation = 39,
RootModeRequiresFullRotation = 40,
InvalidNamespace = 41,
InvalidUpgradeAuthority = 42,
NamespaceAlreadyExists = 43,
CertificateRequired = 44,
}
impl From<ShineUsersError> for ProgramError {
@@ -161,7 +165,7 @@ pub struct CreateUserPdaArgs {
pub server_addresses: Vec<ServerAddressRecordV12>,
pub access_servers: Vec<String>,
pub signature: [u8; 64],
pub promo_seller_login: Option<String>,
pub registrar_signature: Option<[u8; 64]>,
}
#[derive(Clone, Debug)]
@@ -198,20 +202,14 @@ pub struct UsersEconomyConfigState {
pub start_bonus_limit: u64,
}
#[derive(Clone, Debug)]
pub struct UpsertPromoSellerArgs {
pub seller_login: String,
pub remaining_sales: u64,
pub min_login_length: u8,
pub signer_pubkey: Pubkey,
}
#[derive(Clone, Debug)]
pub struct PromoSellerState {
pub version: u8,
pub remaining_sales: u64,
pub min_login_length: u8,
pub signer_pubkey: Pubkey,
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct NamespaceState {
pub namespace_type: u8,
pub min_localpart_len: u8,
pub namespace: String,
pub registration_fee: u64,
pub registrar_pubkey: Option<Pubkey>,
pub server_login: Option<String>,
}
struct Reader<'a> {
@@ -294,7 +292,11 @@ 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_UPSERT_PROMO_SELLER => dispatch_upsert_promo_seller(program_id, accounts, r),
IX_CREATE_NAMESPACE => {
let args = parse_namespace_args(&mut r)?;
r.finish()?;
process_create_namespace(program_id, accounts, args)
},
IX_CLOSE_LEGACY_USER_PDA => dispatch_close_legacy_user_pda(program_id, accounts, r),
_ => Err(ProgramError::from(ShineUsersError::InvalidInstruction)),
}
@@ -312,15 +314,19 @@ fn dispatch_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], mut r
process_update_user_pda(program_id, accounts, args)
}
fn dispatch_upsert_promo_seller(program_id: &Pubkey, accounts: &[AccountInfo], mut r: Reader<'_>) -> ProgramResult {
let args = UpsertPromoSellerArgs {
seller_login: r.read_string_u8()?,
remaining_sales: r.read_u64()?,
min_login_length: r.read_u8()?,
signer_pubkey: r.read_pubkey()?,
fn parse_namespace_args(r: &mut Reader<'_>) -> Result<NamespaceState, ProgramError> {
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 (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()?;
process_upsert_promo_seller(program_id, accounts, args)
let state = NamespaceState { namespace_type, min_localpart_len, namespace, registration_fee, registrar_pubkey, server_login };
validate_namespace_state(&state)?;
Ok(state)
}
fn parse_server_addresses(r: &mut Reader<'_>) -> Result<Vec<ServerAddressRecordV12>, ProgramError> {
@@ -356,7 +362,11 @@ fn parse_create_args(r: &mut Reader<'_>) -> Result<CreateUserPdaArgs, ProgramErr
server_addresses: parse_server_addresses(r)?,
access_servers: parse_access_servers(r)?,
signature: r.read_fixed_64()?,
promo_seller_login: if r.remaining() > 0 { Some(r.read_string_u8()?) } else { None },
registrar_signature: match r.read_u8()? {
0 => None,
1 => Some(r.read_fixed_64()?),
_ => return Err(ShineUsersError::InvalidInstruction.into()),
},
})
}
@@ -433,11 +443,11 @@ fn process_update_users_economy_config(program_id: &Pubkey, accounts: &[AccountI
let mut it = accounts.iter();
let signer = next_account_info(&mut it)?;
let users_economy_config_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, ShineUsersError::InvalidSigner);
let dao_authority = Pubkey::from_str(settings::DAO_AUTHORITY).map_err(|_| ProgramError::from(ShineUsersError::InvalidSigner))?;
require_keys_eq!(dao_authority, *signer.key, ShineUsersError::InvalidSigner);
validate_upgrade_authority(program_id, signer, program_ai, programdata_ai)?;
let (expected_pda, _) = find_users_economy_config_pda(program_id);
require_keys_eq!(expected_pda, *users_economy_config_pda.key, ShineUsersError::InvalidPdaAddress);
require!(users_economy_config_pda.owner == program_id, ShineUsersError::InvalidPdaAddress);
@@ -451,46 +461,55 @@ fn process_update_users_economy_config(program_id: &Pubkey, accounts: &[AccountI
Ok(())
}
fn process_upsert_promo_seller(program_id: &Pubkey, accounts: &[AccountInfo], args: UpsertPromoSellerArgs) -> ProgramResult {
fn process_create_namespace(program_id: &Pubkey, accounts: &[AccountInfo], state: NamespaceState) -> ProgramResult {
let mut it = accounts.iter();
let signer = next_account_info(&mut it)?;
let promo_seller_pda = 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)?;
// Для free namespace сервер обязан иметь уже созданную настоящую PDA 1.2.
let registered_server = if state.namespace_type == 2 { Some(next_account_info(&mut it)?) } else { None };
require!(it.next().is_none(), ShineUsersError::InvalidInstruction);
require!(signer.is_signer, ShineUsersError::InvalidSigner);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_login(&args.seller_login)?;
require!((1..=20).contains(&args.min_login_length), ShineUsersError::InvalidPromoSellerState);
let dao_authority = Pubkey::from_str(settings::DAO_AUTHORITY).map_err(|_| ProgramError::from(ShineUsersError::InvalidSigner))?;
require_keys_eq!(dao_authority, *signer.key, ShineUsersError::InvalidSigner);
let seller_seed = login_seed_normalized(&args.seller_login);
let (expected_pda, bump) = find_promo_seller_pda(program_id, &seller_seed);
require_keys_eq!(expected_pda, *promo_seller_pda.key, ShineUsersError::InvalidPdaAddress);
if promo_seller_pda.owner == &system_program::id() {
create_pda_account(
signer,
promo_seller_pda,
system_program_ai,
program_id,
&[settings::PROMO_SELLER_PDA_SEED_PREFIX.as_bytes(), seller_seed.as_bytes(), &[bump]],
settings::PROMO_SELLER_PDA_SPACE,
)?;
} else {
require!(promo_seller_pda.owner == program_id, ShineUsersError::InvalidPdaAddress);
ensure_pda_size_and_rent(promo_seller_pda, signer, system_program_ai, settings::PROMO_SELLER_PDA_SPACE)?;
validate_upgrade_authority(program_id, signer, program_ai, programdata_ai)?;
if let Some(server_ai) = registered_server {
let login = state.server_login.as_deref().ok_or(ShineUsersError::InvalidNamespace)?;
require_keys_eq!(*server_ai.key, find_user_pda(program_id, login).0, ShineUsersError::InvalidPdaAddress);
require!(server_ai.owner == program_id, ShineUsersError::InvalidAccountOwner);
let server_record = deserialize_record_v12_from_pda(&read_pda_all(server_ai)?)?;
require!(server_record.login == login && !server_record.server_addresses.is_empty(), ShineUsersError::InvalidNamespace);
}
validate_users_economy_config_pda(program_id, economy_pda)?;
read_users_economy_config(economy_pda)?;
require!(!economy_pda.is_writable, ShineUsersError::InvalidAccountData);
validate_namespace_state(&state)?;
let (expected, bump) = find_namespace_pda(program_id, &state.namespace);
require_keys_eq!(*namespace_pda.key, expected, ShineUsersError::InvalidPdaAddress);
require!(namespace_pda.owner == &system_program::id() && namespace_pda.data_is_empty(), ShineUsersError::NamespaceAlreadyExists);
let data = serialize_namespace(&state);
let seed = hash(format!("{}{}", settings::NAMESPACE_PDA_SEED_PREFIX, state.namespace).as_bytes()).to_bytes();
create_pda_account(signer, namespace_pda, system_program_ai, program_id, &[&seed, &[bump]], data.len())?;
write_pda_exact(namespace_pda, &data)
}
let state = PromoSellerState {
version: 1,
remaining_sales: args.remaining_sales,
min_login_length: args.min_login_length,
signer_pubkey: args.signer_pubkey,
};
write_pda_exact(promo_seller_pda, &serialize_promo_seller_state(&state))?;
/// Проверяем не просто подписанта, а актуальную authority ProgramData ИМЕННО этой программы.
/// Bincode layout UpgradeableLoaderState: Program = [2:u32LE, programdata:32],
/// ProgramData = [3:u32LE, slot:u64LE, Option<Pubkey>:1+32].
fn validate_upgrade_authority(program_id: &Pubkey, signer: &AccountInfo, program_ai: &AccountInfo, programdata_ai: &AccountInfo) -> ProgramResult {
require!(signer.is_signer, ShineUsersError::InvalidSigner);
require_keys_eq!(*program_ai.key, *program_id, ShineUsersError::InvalidUpgradeAuthority);
require!(program_ai.executable && *program_ai.owner == bpf_loader_upgradeable::id(), ShineUsersError::InvalidUpgradeAuthority);
let program_data = program_ai.try_borrow_data()?;
require!(program_data.len() >= 36 && program_data[0..4] == 2u32.to_le_bytes(), ShineUsersError::InvalidUpgradeAuthority);
require!(program_data[4..36] == programdata_ai.key.to_bytes(), ShineUsersError::InvalidUpgradeAuthority);
require!(*programdata_ai.owner == bpf_loader_upgradeable::id(), ShineUsersError::InvalidUpgradeAuthority);
let pd = programdata_ai.try_borrow_data()?;
require!(pd.len() >= 45 && pd[0..4] == 3u32.to_le_bytes(), ShineUsersError::InvalidUpgradeAuthority);
require!(pd[12] == 1 && pd[13..45] == signer.key.to_bytes(), ShineUsersError::InvalidUpgradeAuthority);
Ok(())
}
@@ -502,38 +521,38 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
let inflow_vault = next_account_info(&mut it)?;
let instructions_sysvar = next_account_info(&mut it)?;
let users_economy_config_pda = next_account_info(&mut it)?;
let login_guard_program = next_account_info(&mut it)?;
let promo_seller_pda = it.next();
let namespace_pda = next_account_info(&mut it)?;
require!(it.next().is_none(), ShineUsersError::InvalidInstruction);
require!(signer.is_signer, ShineUsersError::InvalidSigner);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_login(&args.login)?;
let namespace_name = validate_full_login(&args.login)?;
require!(!namespace_pda.is_writable, ShineUsersError::InvalidAccountData);
let namespace = read_namespace(program_id, namespace_pda, namespace_name)?;
let local_len = args.login.split('@').next().unwrap().len();
require!(local_len >= namespace.min_localpart_len as usize, ShineUsersError::InvalidLogin);
validate_server_addresses(&args.server_addresses)?;
validate_access_servers(&args.access_servers)?;
for server in &args.access_servers { validate_full_login(server)?; }
validate_inflow_vault(inflow_vault)?;
require!(args.additional_limit % settings::LIMIT_STEP == 0, ShineUsersError::InvalidLimitIncrement);
require_keys_eq!(*login_guard_program.key, Pubkey::from_str(settings::SHINE_LOGIN_GUARD_PROGRAM_ID).map_err(|_| ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?, ShineUsersError::InvalidLoginGuardResponse);
validate_users_economy_config_pda(program_id, users_economy_config_pda)?;
let promo_context = if let Some(seller_login) = args.promo_seller_login.as_deref().filter(|value| !value.trim().is_empty()) {
let seller_pda = promo_seller_pda.ok_or(ProgramError::from(ShineUsersError::InvalidInstruction))?;
Some(verify_promo_registration(program_id, instructions_sysvar, seller_pda, &args.login, seller_login)?)
} else {
require!(promo_seller_pda.is_none(), ShineUsersError::InvalidInstruction);
None
};
if promo_context.is_none() {
classify_login_or_fail(login_guard_program, &args.login)?;
}
require!(!users_economy_config_pda.is_writable, ShineUsersError::InvalidAccountData);
let economy = read_users_economy_config(users_economy_config_pda)?;
let login_seed = login_seed_normalized(&args.login);
let (expected_pda, bump) = find_user_pda(program_id, &login_seed);
let (expected_pda, bump) = find_user_pda(program_id, &args.login);
require_keys_eq!(expected_pda, *user_pda.key, ShineUsersError::InvalidPdaAddress);
require!(user_pda.owner == &system_program::id(), ShineUsersError::UserAlreadyExists);
require!(user_pda.data_is_empty(), ShineUsersError::UserAlreadyExists);
match namespace.namespace_type {
1 => require!(args.registrar_signature.is_none(), ShineUsersError::InvalidInstruction),
2 => {
let signature = args.registrar_signature.as_ref().ok_or(ShineUsersError::CertificateRequired)?;
let registrar = namespace.registrar_pubkey.ok_or(ShineUsersError::InvalidNamespace)?;
let message = certificate_inner_message(&args.login, &args.root_key, &args.blockchain_key, &args.client_key)?;
verify_ed25519_signature_instruction(instructions_sysvar, -3, &registrar, signature, &message)?;
},
_ => return Err(ShineUsersError::InvalidNamespace.into()),
}
let start_balance_u64 = economy.start_bonus_limit.checked_add(args.additional_limit).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
let start_balance = u32::try_from(start_balance_u64).map_err(|_| ProgramError::from(ShineUsersError::PaidLimitTooLarge))?;
@@ -572,16 +591,12 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
user_pda,
system_program_ai,
program_id,
&[settings::USER_PDA_SEED_PREFIX.as_bytes(), login_seed.as_bytes(), &[bump]],
&[&user_pda_seed(&record.login), &[bump]],
settings::USER_PDA_SPACE,
)?;
write_pda_exact(user_pda, &serialized)?;
if let Some(promo) = promo_context {
write_pda_exact(promo.promo_seller_pda, &serialize_promo_seller_state(&promo.updated_state))?;
}
let total_fee = economy.registration_fee_lamports.checked_add(limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
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)?;
Ok(())
}
@@ -598,7 +613,10 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args:
require!(signer.is_signer, ShineUsersError::InvalidSigner);
require_keys_eq!(*system_program_ai.key, system_program::id(), ShineUsersError::InvalidSystemProgram);
validate_login(&args.login)?;
// Старые аккаунты без namespace сохраняют прежнюю возможность update.
// Новый create всегда требует полный login@namespace.
if args.login.contains('@') { validate_full_login(&args.login)?; }
else { validate_legacy_login(&args.login)?; }
validate_server_addresses(&args.server_addresses)?;
validate_access_servers(&args.access_servers)?;
validate_inflow_vault(inflow_vault)?;
@@ -606,8 +624,12 @@ fn process_update_user_pda(program_id: &Pubkey, accounts: &[AccountInfo], args:
validate_users_economy_config_pda(program_id, users_economy_config_pda)?;
let economy = read_users_economy_config(users_economy_config_pda)?;
let normalized_login = login_seed_normalized(&args.login);
require_keys_eq!(find_user_pda(program_id, &normalized_login).0, *user_pda.key, ShineUsersError::InvalidPdaAddress);
let expected_pda = if args.login.contains('@') {
find_user_pda(program_id, &args.login).0
} else {
find_legacy_user_pda(program_id, &args.login.to_ascii_lowercase()).0
};
require_keys_eq!(expected_pda, *user_pda.key, ShineUsersError::InvalidPdaAddress);
require!(user_pda.owner == program_id, ShineUsersError::InvalidPdaAddress);
let raw = read_pda_all(user_pda)?;
@@ -703,9 +725,8 @@ fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo],
require!(caller.is_writable, ShineUsersError::InvalidAccountData);
require!(user_pda.is_writable, ShineUsersError::InvalidAccountData);
validate_login(&args.login)?;
let normalized_login = login_seed_normalized(&args.login);
require_keys_eq!(find_user_pda(program_id, &normalized_login).0, *user_pda.key, ShineUsersError::InvalidPdaAddress);
validate_legacy_login(&args.login)?;
require_keys_eq!(find_legacy_user_pda(program_id, &args.login.to_ascii_lowercase()).0, *user_pda.key, ShineUsersError::InvalidPdaAddress);
require!(user_pda.owner == program_id, ShineUsersError::InvalidPdaAddress);
let raw = read_pda_all(user_pda)?;
@@ -724,66 +745,6 @@ fn process_close_legacy_user_pda(program_id: &Pubkey, accounts: &[AccountInfo],
Ok(())
}
struct PromoRegistrationContext<'a> {
promo_seller_pda: &'a AccountInfo<'a>,
updated_state: PromoSellerState,
}
fn verify_promo_registration<'a>(
program_id: &Pubkey,
instructions_sysvar: &AccountInfo<'a>,
promo_seller_pda: &'a AccountInfo<'a>,
target_login: &str,
seller_login: &str,
) -> Result<PromoRegistrationContext<'a>, ProgramError> {
validate_login(seller_login)?;
let normalized_seller_login = login_seed_normalized(&seller_login);
let expected_pda = find_promo_seller_pda(program_id, &normalized_seller_login).0;
require_keys_eq!(expected_pda, *promo_seller_pda.key, ShineUsersError::InvalidPdaAddress);
require!(promo_seller_pda.owner == program_id, ShineUsersError::PromoSellerNotFound);
let state = read_promo_seller_state(promo_seller_pda)?;
require!(state.remaining_sales > 0, ShineUsersError::PromoSalesExhausted);
require!(target_login.len() >= state.min_login_length as usize, ShineUsersError::PromoLoginTooShort);
let message = build_promo_sign_message(target_login);
verify_ed25519_instruction_pubkey_message(instructions_sysvar, -3, &state.signer_pubkey, message.as_bytes())
.map_err(|_| ProgramError::from(ShineUsersError::PromoSignatureMismatch))?;
let updated_state = PromoSellerState {
version: state.version,
remaining_sales: state.remaining_sales.saturating_sub(1),
min_login_length: state.min_login_length,
signer_pubkey: state.signer_pubkey,
};
Ok(PromoRegistrationContext {
promo_seller_pda,
updated_state,
})
}
fn classify_login_or_fail(login_guard_program: &AccountInfo, login: &str) -> ProgramResult {
let login_guard_program_id = Pubkey::from_str(settings::SHINE_LOGIN_GUARD_PROGRAM_ID)
.map_err(|_| ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?;
require_keys_eq!(*login_guard_program.key, login_guard_program_id, ShineUsersError::InvalidLoginGuardResponse);
let mut data = Vec::with_capacity(1 + 4 + login.len());
data.push(LOGIN_GUARD_IX_CLASSIFY_LOGIN);
data.extend_from_slice(&(login.len() as u32).to_le_bytes());
data.extend_from_slice(login.as_bytes());
let ix = Instruction { program_id: login_guard_program_id, accounts: vec![], data };
invoke(&ix, &[login_guard_program.clone()])?;
let (program_id, raw) = get_return_data().ok_or(ProgramError::from(ShineUsersError::InvalidLoginGuardResponse))?;
require_keys_eq!(program_id, login_guard_program_id, ShineUsersError::InvalidLoginGuardResponse);
require!(raw.len() == 4, ShineUsersError::InvalidLoginGuardResponse);
let class = u32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]]);
match class {
0 => Ok(()),
1 => Err(ProgramError::from(ShineUsersError::PremiumLogin)),
2 => Err(ProgramError::from(ShineUsersError::TrademarkLoginRequiresReview)),
_ => Err(ProgramError::from(ShineUsersError::InvalidLoginGuardResponse)),
}
}
fn serialize_users_economy_config(state: &UsersEconomyConfigState) -> Vec<u8> {
let mut out = Vec::with_capacity(1 + 8 + 8 + 8);
out.push(state.version);
@@ -793,15 +754,6 @@ fn serialize_users_economy_config(state: &UsersEconomyConfigState) -> Vec<u8> {
out
}
fn serialize_promo_seller_state(state: &PromoSellerState) -> Vec<u8> {
let mut out = Vec::with_capacity(1 + 8 + 1 + 32);
out.push(state.version);
out.extend_from_slice(&state.remaining_sales.to_le_bytes());
out.push(state.min_login_length);
out.extend_from_slice(state.signer_pubkey.as_ref());
out
}
fn validate_users_economy_config_pda(program_id: &Pubkey, pda: &AccountInfo) -> ProgramResult {
let (expected_pda, _) = find_users_economy_config_pda(program_id);
require_keys_eq!(expected_pda, *pda.key, ShineUsersError::InvalidPdaAddress);
@@ -812,7 +764,7 @@ fn validate_users_economy_config_pda(program_id: &Pubkey, pda: &AccountInfo) ->
fn read_users_economy_config(pda: &AccountInfo) -> Result<UsersEconomyConfigState, ProgramError> {
let raw = read_pda_all(pda)?;
require!(!raw.is_empty(), ShineUsersError::EmptyPdaData);
require!(raw.len() >= 25, ShineUsersError::InvalidAccountData);
require!(raw.len() >= 25 && raw[0] == 1, ShineUsersError::InvalidAccountData);
Ok(UsersEconomyConfigState {
version: raw[0],
registration_fee_lamports: u64::from_le_bytes(raw[1..9].try_into().unwrap()),
@@ -821,19 +773,6 @@ fn read_users_economy_config(pda: &AccountInfo) -> Result<UsersEconomyConfigStat
})
}
fn read_promo_seller_state(pda: &AccountInfo) -> Result<PromoSellerState, ProgramError> {
let raw = read_pda_all(pda)?;
require!(!raw.is_empty(), ShineUsersError::PromoSellerNotFound);
require!(raw.len() >= 42, ShineUsersError::InvalidPromoSellerState);
let signer_pubkey = Pubkey::new_from_array(raw[10..42].try_into().map_err(|_| ProgramError::from(ShineUsersError::InvalidPromoSellerState))?);
Ok(PromoSellerState {
version: raw[0],
remaining_sales: u64::from_le_bytes(raw[1..9].try_into().unwrap()),
min_login_length: raw[9],
signer_pubkey,
})
}
fn record_format_minor(raw: &[u8]) -> Result<u8, ProgramError> {
require!(raw.len() >= 9, ShineUsersError::InvalidRecordData);
require!(sol_memcmp(&raw[0..5], MAGIC, 5) == 0, ShineUsersError::InvalidRecordMagic);
@@ -1131,20 +1070,89 @@ fn le_u16(data: &[u8], offset: usize) -> Result<u16, ProgramError> {
Ok(u16::from_le_bytes([s[0], s[1]]))
}
fn build_promo_sign_message(login: &str) -> String {
let mut message = String::with_capacity(settings::PROMO_SIGN_PREFIX.len() + login.len());
message.push_str(settings::PROMO_SIGN_PREFIX);
message.push_str(login);
message
}
fn validate_login(login: &str) -> ProgramResult {
require!(!login.is_empty(), ShineUsersError::InvalidLogin);
require!(login.len() <= 20, ShineUsersError::InvalidLogin);
for ch in login.chars() { if !(ch.is_ascii_alphabetic() || ch.is_ascii_digit() || ch == '_') { return Err(ProgramError::from(ShineUsersError::InvalidLogin)); } }
fn validate_legacy_login(value: &str) -> ProgramResult {
require!(!value.is_empty() && value.len() <= 20 && value.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_'), ShineUsersError::InvalidLogin);
Ok(())
}
fn login_seed_normalized(login: &str) -> String { login.to_ascii_lowercase() }
fn validate_namespace_name(value: &str) -> ProgramResult {
require!(!value.is_empty() && value.len() <= 29, ShineUsersError::InvalidNamespace);
require!(value.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_'), ShineUsersError::InvalidNamespace);
Ok(())
}
fn validate_full_login(login: &str) -> Result<&str, ProgramError> {
require!(login.len() <= 30, ShineUsersError::InvalidLogin);
let (local, namespace) = login.split_once('@').ok_or(ShineUsersError::InvalidLogin)?;
validate_namespace_name(namespace)?;
require!(!local.is_empty(), ShineUsersError::InvalidLogin);
require!(local.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b == b'_'), ShineUsersError::InvalidLogin);
Ok(namespace)
}
pub fn validate_namespace_state(state: &NamespaceState) -> ProgramResult {
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 {
1 => require!(state.registrar_pubkey.is_none() && state.server_login.is_none(), ShineUsersError::InvalidNamespace),
2 => {
require!(state.registrar_pubkey.is_some(), ShineUsersError::InvalidNamespace);
validate_full_login(state.server_login.as_deref().ok_or(ShineUsersError::InvalidNamespace)?)?;
},
_ => return Err(ShineUsersError::InvalidNamespace.into()),
}
Ok(())
}
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];
out.extend_from_slice(state.namespace.as_bytes());
out.extend_from_slice(&state.registration_fee.to_le_bytes());
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);
out.extend_from_slice(server.as_bytes());
}
out
}
fn read_namespace(program_id: &Pubkey, ai: &AccountInfo, name: &str) -> Result<NamespaceState, ProgramError> {
let expected = find_namespace_pda(program_id, name).0;
require_keys_eq!(expected, *ai.key, ShineUsersError::InvalidPdaAddress);
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);
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 (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 };
require!(state.namespace == name, ShineUsersError::InvalidNamespace);
validate_namespace_state(&state)?;
Ok(state)
}
pub fn certificate_inner_message(login: &str, root: &Pubkey, blockchain: &Pubkey, client: &Pubkey) -> Result<Vec<u8>, ProgramError> {
validate_full_login(login)?;
let mut msg = CERTIFICATE_DOMAIN.to_vec();
msg.extend_from_slice(&[1, 0, login.len() as u8]);
msg.extend_from_slice(login.as_bytes());
msg.extend_from_slice(root.as_ref());
msg.extend_from_slice(blockchain.as_ref());
msg.extend_from_slice(client.as_ref());
Ok(msg)
}
pub fn user_pda_seed(login: &str) -> [u8; 32] {
hash(format!("{}{}", settings::USER_PDA_SEED_PREFIX, login).as_bytes()).to_bytes()
}
fn validate_server_addresses(addresses: &[ServerAddressRecordV12]) -> ProgramResult {
require!(addresses.len() <= 1, ShineUsersError::InvalidRecordData);
@@ -1158,7 +1166,8 @@ fn validate_server_addresses(addresses: &[ServerAddressRecordV12]) -> ProgramRes
fn validate_access_servers(servers: &[String]) -> ProgramResult {
require!(servers.len() <= 1, ShineUsersError::InvalidRecordData);
for login in servers {
validate_login(login)?;
if login.contains('@') { validate_full_login(login)?; }
else { validate_legacy_login(login)?; }
}
Ok(())
}
@@ -1238,9 +1247,13 @@ fn ensure_pda_size_and_rent<'a>(pda: &AccountInfo<'a>, payer: &AccountInfo<'a>,
pda.realloc(required_len, false)
}
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) }
pub fn find_user_pda(program_id: &Pubkey, login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[&user_pda_seed(login)], program_id) }
fn find_legacy_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) }
pub fn find_namespace_pda(program_id: &Pubkey, name: &str) -> (Pubkey, u8) {
let seed = hash(format!("{}{}", settings::NAMESPACE_PDA_SEED_PREFIX, name).as_bytes()).to_bytes();
Pubkey::find_program_address(&[&seed], program_id)
}
fn find_users_economy_config_pda(program_id: &Pubkey) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::USERS_ECONOMY_CONFIG_SEED], program_id) }
fn find_promo_seller_pda(program_id: &Pubkey, seller_login: &str) -> (Pubkey, u8) { Pubkey::find_program_address(&[settings::PROMO_SELLER_PDA_SEED_PREFIX.as_bytes(), seller_login.as_bytes()], program_id) }
fn limit_fee_lamports(limit_delta: u64, lamports_per_limit_step: u64) -> Result<u64, ProgramError> { (limit_delta / settings::LIMIT_STEP).checked_mul(lamports_per_limit_step).ok_or(ProgramError::from(ShineUsersError::MathOverflow)) }
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) }
@@ -2,27 +2,17 @@
pub const USER_PDA_SEED_PREFIX: &str = "user_login=";
/// Seed PDA с экономическими параметрами программы `shine_users`.
pub const USERS_ECONOMY_CONFIG_SEED: &[u8] = b"shine_users_economy_config";
/// Префикс seed для PDA продавца promo-логинов.
pub const PROMO_SELLER_PDA_SEED_PREFIX: &str = "promo_seller=";
/// Префикс хешируемого namespace PDA seed.
pub const NAMESPACE_PDA_SEED_PREFIX: &str = "namespace=";
/// Стартовый размер PDA пользователя, дальше запись может расширяться через realloc.
pub const USER_PDA_SPACE: usize = 768;
/// Размер PDA с экономическими параметрами `shine_users`.
pub const USERS_ECONOMY_CONFIG_SPACE: usize = 32;
/// Размер PDA продавца promo-логинов.
pub const PROMO_SELLER_PDA_SPACE: usize = 64;
/// Адрес DAO authority, который имеет право обновлять economy-конфиг.
pub const DAO_AUTHORITY: &str = "aiShm43fZjm3YkMs22sYL1bpXaL3bVxv7SSraPHzVgq";
/// Адрес программы `shine_payments`, от которой вычисляется PDA inflow-вольта.
pub const SHINE_PAYMENTS_PROGRAM_ID: &str = "SHiPmXbM9Fs9khzRUW3TGKsS2W84aqaXTxs3ZkajW9v";
/// Seed inflow-вольта в программе `shine_payments`.
pub const SHINE_PAYMENTS_INFLOW_VAULT_SEED: &[u8] = b"shine_payments_inflow_vault";
/// Адрес отдельной программы проверки премиальности логина.
pub const SHINE_LOGIN_GUARD_PROGRAM_ID: &str = "SHiGxGsXGioQYCYhchQ5R7KWoxN5UjFAFsucPf6sfnh";
/// Доменный префикс для подписи promo-кода.
pub const PROMO_SIGN_PREFIX: &str = "shine_promo_v1:";
/// Стартовая комиссия регистрации (0.01 SOL) для initial economy-конфига.
pub const START_REGISTRATION_FEE_LAMPORTS: u64 = 10_000_000;
/// Шаг пополнения лимита.