aidar/SHiNE-server
SHA256
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Сократить promo-аргументы регистрации в Solana

Browse Source
This commit is contained in:
AidarKC
2026-06-30 18:40:33 +04:00
parent 0a416a2f5c
commit 63f13a4c29
4 changed files with 75 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shine-solana/shine/programs/shine_users/src/lib.rs
+29 -81
View File
@@ -50,7 +50,6 @@ const IX_CREATE_USER_PDA: u8 = 3;
const IX_UPDATE_USER_PDA: u8 = 4;
const IX_UPSERT_PROMO_SELLER: u8 = 5;
const LOGIN_GUARD_IX_CLASSIFY_LOGIN: u8 = 1;
const PROMO_CODE_VERSION_PREFIX: char = '1';
#[repr(u32)]
#[derive(Clone, Copy, Debug)]
@@ -150,7 +149,7 @@ pub struct CreateUserPdaArgs {
pub additional_limit: u64,
pub fields: UserMutableFields,
pub signature: [u8; 64],
pub promo_code: Option<String>,
pub promo_seller_login: Option<String>,
}
#[derive(Clone, Debug)]
@@ -345,7 +344,7 @@ fn parse_create_args(r: &mut Reader<'_>) -> Result<CreateUserPdaArgs, ProgramErr
additional_limit: r.read_u64()?,
fields: parse_fields(r)?,
signature: r.read_fixed_64()?,
promo_code: if r.remaining() > 0 { Some(r.read_string_u8()?) } else { None },
promo_seller_login: if r.remaining() > 0 { Some(r.read_string_u8()?) } else { None },
})
}
@@ -543,9 +542,9 @@ fn process_create_user_pda<'a>(program_id: &Pubkey, accounts: &'a [AccountInfo<'
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(promo_code) = args.promo_code.as_deref().filter(|value| !value.trim().is_empty()) {
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, promo_code)?)
Some(verify_promo_registration(program_id, instructions_sysvar, seller_pda, &args.login, seller_login)?)
} else {
require!(promo_seller_pda.is_none(), ShineUsersError::InvalidInstruction);
None
@@ -728,9 +727,9 @@ fn verify_promo_registration<'a>(
instructions_sysvar: &AccountInfo<'a>,
promo_seller_pda: &'a AccountInfo<'a>,
target_login: &str,
promo_code: &str,
seller_login: &str,
) -> Result<PromoRegistrationContext<'a>, ProgramError> {
let (seller_login, signature58) = parse_promo_code(promo_code)?;
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);
@@ -740,9 +739,8 @@ fn verify_promo_registration<'a>(
require!(state.remaining_sales > 0, ShineUsersError::PromoSalesExhausted);
require!(target_login.len() >= state.min_login_length as usize, ShineUsersError::PromoLoginTooShort);
let signature = decode_base58_fixed_64(&signature58)?;
let message = build_promo_sign_message(target_login);
verify_ed25519_signature_instruction(instructions_sysvar, -3, &state.signer_pubkey, &signature, message.as_bytes())
verify_ed25519_instruction_pubkey_message(instructions_sysvar, -3, &state.signer_pubkey, message.as_bytes())
.map_err(|_| ProgramError::from(ShineUsersError::PromoSignatureMismatch))?;
let updated_state = PromoSellerState {
@@ -1071,27 +1069,38 @@ fn serialize_last_block_state(record: &UserRecord) -> Result<Vec<u8>, ProgramErr
Ok(out)
}
struct ParsedEd25519Ref<'a> {
struct ParsedEd25519Data {
pubkey: Pubkey,
signature: [u8; 64],
message: &'a [u8],
message: Vec<u8>,
}
fn verify_ed25519_signature_instruction(instructions_sysvar: &AccountInfo, index_relative_to_current: i64, expected_pubkey: &Pubkey, expected_signature: &[u8; 64], expected_message: &[u8]) -> ProgramResult {
require_keys_eq!(*instructions_sysvar.key, solana_program::sysvar::instructions::id(), ShineUsersError::InvalidSignature);
let current_index = load_current_index_checked(instructions_sysvar).map_err(|_| ProgramError::from(ShineUsersError::InvalidSignature))? as i64;
let target_index = current_index.checked_add(index_relative_to_current).ok_or(ProgramError::from(ShineUsersError::InvalidSignature))?;
require!(target_index >= 0, ShineUsersError::InvalidSignature);
let ed_ix = load_instruction_at_checked(target_index as usize, instructions_sysvar).map_err(|_| ProgramError::from(ShineUsersError::InvalidSignature))?;
require_keys_eq!(ed_ix.program_id, solana_program::ed25519_program::id(), ShineUsersError::InvalidSignature);
let parsed = parse_ed25519_ix(ed_ix.data.as_slice())?;
let parsed = load_parsed_ed25519_instruction(instructions_sysvar, index_relative_to_current)?;
require!(parsed.pubkey == *expected_pubkey, ShineUsersError::InvalidSignature);
require!(parsed.signature == *expected_signature, ShineUsersError::InvalidSignature);
require!(parsed.message == expected_message, ShineUsersError::InvalidSignature);
Ok(())
}
fn parse_ed25519_ix<'a>(data: &'a [u8]) -> Result<ParsedEd25519Ref<'a>, ProgramError> {
fn verify_ed25519_instruction_pubkey_message(instructions_sysvar: &AccountInfo, index_relative_to_current: i64, expected_pubkey: &Pubkey, expected_message: &[u8]) -> ProgramResult {
let parsed = load_parsed_ed25519_instruction(instructions_sysvar, index_relative_to_current)?;
require!(parsed.pubkey == *expected_pubkey, ShineUsersError::InvalidSignature);
require!(parsed.message == expected_message, ShineUsersError::InvalidSignature);
Ok(())
}
fn load_parsed_ed25519_instruction(instructions_sysvar: &AccountInfo, index_relative_to_current: i64) -> Result<ParsedEd25519Data, ProgramError> {
require_keys_eq!(*instructions_sysvar.key, solana_program::sysvar::instructions::id(), ShineUsersError::InvalidSignature);
let current_index = load_current_index_checked(instructions_sysvar).map_err(|_| ProgramError::from(ShineUsersError::InvalidSignature))? as i64;
let target_index = current_index.checked_add(index_relative_to_current).ok_or(ProgramError::from(ShineUsersError::InvalidSignature))?;
require!(target_index >= 0, ShineUsersError::InvalidSignature);
let ed_ix = load_instruction_at_checked(target_index as usize, instructions_sysvar).map_err(|_| ProgramError::from(ShineUsersError::InvalidSignature))?;
require_keys_eq!(ed_ix.program_id, solana_program::ed25519_program::id(), ShineUsersError::InvalidSignature);
parse_ed25519_ix(ed_ix.data.as_slice())
}
fn parse_ed25519_ix(data: &[u8]) -> Result<ParsedEd25519Data, ProgramError> {
require!(data.len() >= 16, ShineUsersError::InvalidSignature);
require!(data[0] == 1, ShineUsersError::InvalidSignature);
let signature_offset = le_u16(data, 2)? as usize;
@@ -1113,7 +1122,7 @@ fn parse_ed25519_ix<'a>(data: &'a [u8]) -> Result<ParsedEd25519Ref<'a>, ProgramE
let message = data.get(message_offset..message_end).ok_or(ProgramError::from(ShineUsersError::InvalidSignature))?;
let mut signature = [0u8; 64]; signature.copy_from_slice(signature_slice);
let pubkey = Pubkey::new_from_array(<[u8; 32]>::try_from(pubkey_slice).map_err(|_| ProgramError::from(ShineUsersError::InvalidSignature))?);
Ok(ParsedEd25519Ref { pubkey, signature, message })
Ok(ParsedEd25519Data { pubkey, signature, message: message.to_vec() })
}
fn le_u16(data: &[u8], offset: usize) -> Result<u16, ProgramError> {
@@ -1122,19 +1131,6 @@ fn le_u16(data: &[u8], offset: usize) -> Result<u16, ProgramError> {
Ok(u16::from_le_bytes([s[0], s[1]]))
}
fn parse_promo_code(value: &str) -> Result<(String, String), ProgramError> {
let trimmed = value.trim();
let mut chars = trimmed.chars();
require!(chars.next() == Some(PROMO_CODE_VERSION_PREFIX), ShineUsersError::InvalidPromoCode);
let rest: String = chars.collect();
let dash_pos = rest.find('-').ok_or(ProgramError::from(ShineUsersError::InvalidPromoCode))?;
let seller_login = rest[..dash_pos].to_string();
let signature58 = rest[dash_pos + 1..].to_string();
require!(!seller_login.is_empty() && !signature58.is_empty(), ShineUsersError::InvalidPromoCode);
validate_login(&seller_login)?;
Ok((seller_login, signature58))
}
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);
@@ -1142,54 +1138,6 @@ fn build_promo_sign_message(login: &str) -> String {
message
}
fn decode_base58_fixed_64(value: &str) -> Result<[u8; 64], ProgramError> {
let decoded = decode_base58(value)?;
<[u8; 64]>::try_from(decoded.as_slice()).map_err(|_| ProgramError::from(ShineUsersError::InvalidPromoCode))
}
fn decode_base58(value: &str) -> Result<Vec<u8>, ProgramError> {
let text = value.trim();
require!(!text.is_empty(), ShineUsersError::InvalidPromoCode);
let mut bytes = vec![0u8];
for ch in text.bytes() {
let digit = base58_value(ch).ok_or(ProgramError::from(ShineUsersError::InvalidPromoCode))? as u32;
let mut carry = digit;
for byte in &mut bytes {
let x = (*byte as u32).checked_mul(58).and_then(|v| v.checked_add(carry)).ok_or(ProgramError::from(ShineUsersError::MathOverflow))?;
*byte = (x & 0xff) as u8;
carry = x >> 8;
}
while carry > 0 {
bytes.push((carry & 0xff) as u8);
carry >>= 8;
}
}
for ch in text.bytes() {
if ch == b'1' {
bytes.push(0);
} else {
break;
}
}
bytes.reverse();
Ok(bytes)
}
fn base58_value(ch: u8) -> Option<u8> {
match ch {
b'1'..=b'9' => Some(ch - b'1'),
b'A'..=b'H' => Some(9 + (ch - b'A')),
b'J'..=b'N' => Some(17 + (ch - b'J')),
b'P'..=b'Z' => Some(22 + (ch - b'P')),
b'a'..=b'k' => Some(33 + (ch - b'a')),
b'm'..=b'z' => Some(44 + (ch - b'm')),
_ => None,
}
}
fn validate_login(login: &str) -> ProgramResult {
require!(!login.is_empty(), ShineUsersError::InvalidLogin);
require!(login.len() <= 20, ShineUsersError::InvalidLogin);