1212 lines
42 KiB
Rust
1212 lines
42 KiB
Rust
use crate::settings;
|
||
use anchor_lang::prelude::*;
|
||
use anchor_lang::solana_program::{
|
||
ed25519_program,
|
||
hash::hashv,
|
||
program::{get_return_data, invoke},
|
||
system_instruction,
|
||
sysvar::instructions::get_instruction_relative,
|
||
};
|
||
use common::utils::{create_pda, safe_read_pda, write_to_pda, ErrCode};
|
||
use std::str::FromStr;
|
||
|
||
const MAGIC: &[u8; 5] = b"SHiNE";
|
||
const FORMAT_MAJOR: u8 = 1;
|
||
const FORMAT_MINOR: u8 = 0;
|
||
const MAX_SYNC_SERVERS: usize = 32;
|
||
const MAX_AUTO_REALLOC_INCREASE: usize = 10_000;
|
||
const ZERO_HASH: [u8; 32] = [0; 32];
|
||
const BLOCK_TYPE_ROOT_KEY: u8 = 1;
|
||
const BLOCK_TYPE_DEVICE_KEY: u8 = 2;
|
||
const BLOCK_TYPE_BLOCKCHAIN_REGISTRY: u8 = 3;
|
||
const BLOCK_TYPE_SERVER_PROFILE: u8 = 30;
|
||
const BLOCK_TYPE_ACCESS_SERVERS: u8 = 40;
|
||
const BLOCK_TYPE_TRUSTED_STATE: u8 = 50;
|
||
const BLOCK_VERSION_0: u8 = 0;
|
||
const BLOCKCHAIN_TYPE_MAIN_USER: u8 = 1;
|
||
const LAST_BLOCK_STATE_PREFIX: &[u8] = b"SHiNE_LAST_BLOCK";
|
||
|
||
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
|
||
pub struct UserMutableFields {
|
||
pub device_key: Pubkey,
|
||
pub blockchain_public_key: Pubkey,
|
||
pub blockchain_name: String,
|
||
pub used_bytes: u64,
|
||
pub last_block_number: u32,
|
||
pub last_block_hash: Vec<u8>,
|
||
pub last_block_signature: Vec<u8>,
|
||
pub arweave_tx_id: String,
|
||
pub is_server: bool,
|
||
pub address_format_type: u8,
|
||
pub address_format_version: u8,
|
||
pub server_address: String,
|
||
pub sync_servers: Vec<String>,
|
||
pub access_servers: Vec<String>,
|
||
pub trusted_count: u8,
|
||
}
|
||
|
||
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
|
||
pub struct CreateUserPdaArgs {
|
||
pub login: String,
|
||
pub root_key: Pubkey,
|
||
pub created_at_ms: u64,
|
||
pub additional_limit: u64,
|
||
pub fields: UserMutableFields,
|
||
pub signature: Vec<u8>,
|
||
}
|
||
|
||
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
|
||
pub struct UpdateUserPdaArgs {
|
||
pub login: String,
|
||
pub root_key: Pubkey,
|
||
pub created_at_ms: u64,
|
||
pub updated_at_ms: u64,
|
||
pub version: u32,
|
||
pub prev_hash: Vec<u8>,
|
||
pub additional_limit: u64,
|
||
pub fields: UserMutableFields,
|
||
pub signature: Vec<u8>,
|
||
}
|
||
|
||
pub struct UserRecord {
|
||
pub created_at_ms: u64,
|
||
pub updated_at_ms: u64,
|
||
pub record_number: u32,
|
||
pub prev_record_hash: [u8; 32],
|
||
pub login: String,
|
||
pub root_key: Pubkey,
|
||
pub device_key: Pubkey,
|
||
pub blockchain: BlockchainRecord,
|
||
pub is_server: bool,
|
||
pub address_format_type: u8,
|
||
pub address_format_version: u8,
|
||
pub server_address: String,
|
||
pub sync_servers: Vec<String>,
|
||
pub access_servers: Vec<String>,
|
||
pub trusted_count: u8,
|
||
pub signature: [u8; 64],
|
||
}
|
||
|
||
pub struct BlockchainRecord {
|
||
pub blockchain_type: u8,
|
||
pub blockchain_name: String,
|
||
pub blockchain_public_key: Pubkey,
|
||
pub paid_limit_bytes: u64,
|
||
pub used_bytes: u64,
|
||
pub last_block_number: u32,
|
||
pub last_block_hash: [u8; 32],
|
||
pub last_block_signature: [u8; 64],
|
||
pub arweave_tx_id: String,
|
||
}
|
||
|
||
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
|
||
pub struct UsersEconomyConfigState {
|
||
pub version: u8,
|
||
pub registration_fee_lamports: u64,
|
||
pub lamports_per_limit_step: u64,
|
||
pub start_bonus_limit: u64,
|
||
}
|
||
|
||
#[derive(Accounts)]
|
||
pub struct CreateUserPda<'info> {
|
||
/// CHECK: подписант транзакции, валидируется Anchor как signer и mut.
|
||
#[account(mut, signer)]
|
||
pub signer: AccountInfo<'info>,
|
||
/// CHECK: PDA пользователя, адрес проверяется вручную через seed в обработчике.
|
||
#[account(mut)]
|
||
pub user_pda: AccountInfo<'info>,
|
||
pub system_program: Program<'info, System>,
|
||
/// CHECK: inflow-вольт shine_payments, адрес проверяется вручную как PDA.
|
||
#[account(mut)]
|
||
pub inflow_vault: AccountInfo<'info>,
|
||
/// CHECK: sysvar инструкций, нужен для проверки встроенной Ed25519Program инструкции.
|
||
pub instructions: AccountInfo<'info>,
|
||
/// CHECK: PDA с экономическими настройками пользователей, адрес проверяется вручную.
|
||
pub users_economy_config_pda: AccountInfo<'info>,
|
||
pub login_guard_program: Program<'info, shine_login_guard::program::ShineLoginGuard>,
|
||
}
|
||
|
||
#[derive(Accounts)]
|
||
pub struct UpdateUserPda<'info> {
|
||
/// CHECK: подписант транзакции, валидируется Anchor как signer и mut.
|
||
#[account(mut, signer)]
|
||
pub signer: AccountInfo<'info>,
|
||
/// CHECK: PDA пользователя, адрес проверяется вручную через seed в обработчике.
|
||
#[account(mut)]
|
||
pub user_pda: AccountInfo<'info>,
|
||
pub system_program: Program<'info, System>,
|
||
/// CHECK: inflow-вольт shine_payments, адрес проверяется вручную как PDA.
|
||
#[account(mut)]
|
||
pub inflow_vault: AccountInfo<'info>,
|
||
/// CHECK: sysvar инструкций, нужен для проверки встроенной Ed25519Program инструкции.
|
||
pub instructions: AccountInfo<'info>,
|
||
/// CHECK: PDA с экономическими настройками пользователей, адрес проверяется вручную.
|
||
pub users_economy_config_pda: AccountInfo<'info>,
|
||
}
|
||
|
||
#[derive(Accounts)]
|
||
pub struct InitUsersEconomyConfig<'info> {
|
||
/// CHECK: подписант и плательщик, валидируется Anchor как signer и mut.
|
||
#[account(mut, signer)]
|
||
pub signer: AccountInfo<'info>,
|
||
/// CHECK: PDA с экономическими настройками пользователей, адрес проверяется вручную.
|
||
#[account(mut)]
|
||
pub users_economy_config_pda: AccountInfo<'info>,
|
||
pub system_program: Program<'info, System>,
|
||
}
|
||
|
||
#[derive(Accounts)]
|
||
pub struct UpdateUsersEconomyConfig<'info> {
|
||
/// CHECK: подписант (должен быть DAO authority из settings).
|
||
#[account(mut, signer)]
|
||
pub signer: AccountInfo<'info>,
|
||
/// CHECK: PDA с экономическими настройками пользователей, адрес проверяется вручную.
|
||
#[account(mut)]
|
||
pub users_economy_config_pda: AccountInfo<'info>,
|
||
}
|
||
|
||
#[derive(AnchorSerialize, AnchorDeserialize, Clone, Debug)]
|
||
pub struct UpdateUsersEconomyConfigArgs {
|
||
pub registration_fee_lamports: u64,
|
||
pub lamports_per_limit_step: u64,
|
||
pub start_bonus_limit: u64,
|
||
}
|
||
|
||
pub fn init_users_economy_config(ctx: Context<InitUsersEconomyConfig>) -> Result<()> {
|
||
let (expected_pda, bump) = find_users_economy_config_pda(ctx.program_id);
|
||
require_keys_eq!(
|
||
expected_pda,
|
||
ctx.accounts.users_economy_config_pda.key(),
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
require!(
|
||
ctx.accounts.users_economy_config_pda.owner == &Pubkey::default(),
|
||
ErrCode::SystemAlreadyInitialized
|
||
);
|
||
|
||
let state = UsersEconomyConfigState {
|
||
version: 1,
|
||
registration_fee_lamports: settings::START_REGISTRATION_FEE_LAMPORTS,
|
||
lamports_per_limit_step: settings::START_LAMPORTS_PER_LIMIT_STEP,
|
||
start_bonus_limit: settings::START_BONUS_LIMIT,
|
||
};
|
||
let bytes = state
|
||
.try_to_vec()
|
||
.map_err(|_| error!(ErrCode::DeserializationError))?;
|
||
let seeds: &[&[u8]] = &[settings::USERS_ECONOMY_CONFIG_SEED, &[bump]];
|
||
create_pda(
|
||
&ctx.accounts.users_economy_config_pda,
|
||
&ctx.accounts.signer,
|
||
&ctx.accounts.system_program.to_account_info(),
|
||
ctx.program_id,
|
||
seeds,
|
||
settings::USERS_ECONOMY_CONFIG_SPACE as u64,
|
||
)?;
|
||
write_to_pda(&ctx.accounts.users_economy_config_pda, &bytes)?;
|
||
Ok(())
|
||
}
|
||
|
||
pub fn update_users_economy_config(
|
||
ctx: Context<UpdateUsersEconomyConfig>,
|
||
args: UpdateUsersEconomyConfigArgs,
|
||
) -> Result<()> {
|
||
let dao_authority =
|
||
Pubkey::from_str(settings::DAO_AUTHORITY).map_err(|_| error!(ErrCode::InvalidSigner))?;
|
||
require_keys_eq!(
|
||
dao_authority,
|
||
ctx.accounts.signer.key(),
|
||
ErrCode::InvalidSigner
|
||
);
|
||
|
||
let (expected_pda, _) = find_users_economy_config_pda(ctx.program_id);
|
||
require_keys_eq!(
|
||
expected_pda,
|
||
ctx.accounts.users_economy_config_pda.key(),
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
require!(
|
||
ctx.accounts.users_economy_config_pda.owner == ctx.program_id,
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
require!(args.lamports_per_limit_step > 0, ErrCode::InvalidRecordData);
|
||
|
||
let mut state = read_users_economy_config(&ctx.accounts.users_economy_config_pda)?;
|
||
state.registration_fee_lamports = args.registration_fee_lamports;
|
||
state.lamports_per_limit_step = args.lamports_per_limit_step;
|
||
state.start_bonus_limit = args.start_bonus_limit;
|
||
let bytes = state
|
||
.try_to_vec()
|
||
.map_err(|_| error!(ErrCode::DeserializationError))?;
|
||
write_to_pda(&ctx.accounts.users_economy_config_pda, &bytes)?;
|
||
Ok(())
|
||
}
|
||
|
||
pub fn create_user_pda(ctx: Context<CreateUserPda>, args: CreateUserPdaArgs) -> Result<()> {
|
||
validate_login(&args.login)?;
|
||
require_keys_eq!(
|
||
ctx.accounts.login_guard_program.key(),
|
||
Pubkey::from_str(settings::SHINE_LOGIN_GUARD_PROGRAM_ID)
|
||
.map_err(|_| error!(ErrCode::InvalidLoginGuardResponse))?,
|
||
ErrCode::InvalidLoginGuardResponse
|
||
);
|
||
classify_login_or_fail(
|
||
&ctx.accounts.login_guard_program.to_account_info(),
|
||
&ctx.accounts.signer,
|
||
&args.login,
|
||
)?;
|
||
validate_fields(&args.fields)?;
|
||
validate_inflow_vault(&ctx.accounts.inflow_vault)?;
|
||
require!(
|
||
args.additional_limit % settings::LIMIT_STEP == 0,
|
||
ErrCode::InvalidLimitIncrement
|
||
);
|
||
let economy = read_users_economy_config(&ctx.accounts.users_economy_config_pda)?;
|
||
|
||
let login_seed = login_seed_normalized(&args.login);
|
||
let (expected_pda, bump) = find_user_pda(ctx.program_id, &login_seed);
|
||
require_keys_eq!(
|
||
expected_pda,
|
||
ctx.accounts.user_pda.key(),
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
require!(
|
||
ctx.accounts.user_pda.owner == &Pubkey::default(),
|
||
ErrCode::UserAlreadyExists
|
||
);
|
||
|
||
let start_balance = economy
|
||
.start_bonus_limit
|
||
.checked_add(args.additional_limit)
|
||
.ok_or(error!(ErrCode::MathOverflow))?;
|
||
|
||
let mut record = UserRecord {
|
||
created_at_ms: args.created_at_ms,
|
||
updated_at_ms: args.created_at_ms,
|
||
record_number: 0,
|
||
prev_record_hash: ZERO_HASH,
|
||
login: args.login.clone(),
|
||
root_key: args.root_key,
|
||
device_key: args.fields.device_key,
|
||
blockchain: BlockchainRecord {
|
||
blockchain_type: BLOCKCHAIN_TYPE_MAIN_USER,
|
||
blockchain_name: args.fields.blockchain_name.clone(),
|
||
blockchain_public_key: args.fields.blockchain_public_key,
|
||
paid_limit_bytes: start_balance,
|
||
used_bytes: args.fields.used_bytes,
|
||
last_block_number: args.fields.last_block_number,
|
||
last_block_hash: vec_to_hash32(&args.fields.last_block_hash)?,
|
||
last_block_signature: vec_to_signature(&args.fields.last_block_signature)?,
|
||
arweave_tx_id: args.fields.arweave_tx_id.clone(),
|
||
},
|
||
is_server: args.fields.is_server,
|
||
address_format_type: args.fields.address_format_type,
|
||
address_format_version: args.fields.address_format_version,
|
||
server_address: args.fields.server_address.clone(),
|
||
sync_servers: args.fields.sync_servers.clone(),
|
||
access_servers: args.fields.access_servers.clone(),
|
||
trusted_count: args.fields.trusted_count,
|
||
signature: [0; 64],
|
||
};
|
||
validate_blockchain_limits(&record.blockchain, 0, 0, true)?;
|
||
verify_last_block_state_signature(&ctx.accounts.instructions, &record)?;
|
||
|
||
let unsigned = serialize_unsigned_record(&record)?;
|
||
record.signature = verify_record_signature(
|
||
&ctx.accounts.instructions,
|
||
&record.root_key,
|
||
&args.signature,
|
||
&unsigned,
|
||
)?;
|
||
|
||
let serialized = serialize_full_record(&record)?;
|
||
require!(
|
||
serialized.len() <= settings::USER_PDA_SPACE,
|
||
ErrCode::RecordTooLarge
|
||
);
|
||
let padded = pad_to_fixed_size(serialized, settings::USER_PDA_SPACE)?;
|
||
|
||
let pda_seeds: &[&[u8]] = &[
|
||
settings::USER_PDA_SEED_PREFIX.as_bytes(),
|
||
login_seed.as_bytes(),
|
||
&[bump],
|
||
];
|
||
create_pda(
|
||
&ctx.accounts.user_pda,
|
||
&ctx.accounts.signer,
|
||
&ctx.accounts.system_program.to_account_info(),
|
||
ctx.program_id,
|
||
pda_seeds,
|
||
settings::USER_PDA_SPACE as u64,
|
||
)?;
|
||
write_to_pda(&ctx.accounts.user_pda, &padded)?;
|
||
|
||
let total_fee = economy
|
||
.registration_fee_lamports
|
||
.checked_add(limit_fee_lamports(
|
||
args.additional_limit,
|
||
economy.lamports_per_limit_step,
|
||
)?)
|
||
.ok_or(error!(ErrCode::MathOverflow))?;
|
||
transfer_lamports(
|
||
&ctx.accounts.signer,
|
||
&ctx.accounts.inflow_vault,
|
||
&ctx.accounts.system_program.to_account_info(),
|
||
total_fee,
|
||
)?;
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn classify_login_or_fail<'info>(
|
||
login_guard_program: &AccountInfo<'info>,
|
||
signer: &AccountInfo<'info>,
|
||
login: &str,
|
||
) -> Result<()> {
|
||
let cpi_ctx = CpiContext::new(
|
||
login_guard_program.clone(),
|
||
shine_login_guard::cpi::accounts::ClassifyLogin {
|
||
signer: signer.to_account_info(),
|
||
},
|
||
);
|
||
shine_login_guard::cpi::classify_login(cpi_ctx, login.to_string())?;
|
||
|
||
let (program_id, raw) = get_return_data().ok_or(error!(ErrCode::InvalidLoginGuardResponse))?;
|
||
require_keys_eq!(
|
||
program_id,
|
||
*login_guard_program.key,
|
||
ErrCode::InvalidLoginGuardResponse
|
||
);
|
||
require!(raw.len() == 4, ErrCode::InvalidLoginGuardResponse);
|
||
let class = u32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]]);
|
||
match class {
|
||
0 => Ok(()),
|
||
1 => Err(error!(ErrCode::PremiumLogin)),
|
||
2 => Err(error!(ErrCode::TrademarkLoginRequiresReview)),
|
||
_ => Err(error!(ErrCode::InvalidLoginGuardResponse)),
|
||
}
|
||
}
|
||
|
||
pub fn update_user_pda(ctx: Context<UpdateUserPda>, args: UpdateUserPdaArgs) -> Result<()> {
|
||
validate_login(&args.login)?;
|
||
validate_fields(&args.fields)?;
|
||
validate_inflow_vault(&ctx.accounts.inflow_vault)?;
|
||
require!(
|
||
args.additional_limit % settings::LIMIT_STEP == 0,
|
||
ErrCode::InvalidLimitIncrement
|
||
);
|
||
let economy = read_users_economy_config(&ctx.accounts.users_economy_config_pda)?;
|
||
|
||
let login_seed = login_seed_normalized(&args.login);
|
||
let (expected_pda, _) = find_user_pda(ctx.program_id, &login_seed);
|
||
require_keys_eq!(
|
||
expected_pda,
|
||
ctx.accounts.user_pda.key(),
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
require!(
|
||
ctx.accounts.user_pda.owner == ctx.program_id,
|
||
ErrCode::InvalidPdaAddress
|
||
);
|
||
|
||
let raw = safe_read_pda(&ctx.accounts.user_pda);
|
||
require!(!raw.is_empty(), ErrCode::EmptyPdaData);
|
||
let old_record = deserialize_record_from_pda(raw.as_slice())?;
|
||
drop(raw);
|
||
|
||
require!(
|
||
old_record.login == args.login,
|
||
ErrCode::ImmutableFieldChanged
|
||
);
|
||
require!(
|
||
old_record.created_at_ms == args.created_at_ms,
|
||
ErrCode::ImmutableFieldChanged
|
||
);
|
||
require_keys_eq!(
|
||
old_record.root_key,
|
||
args.root_key,
|
||
ErrCode::ImmutableFieldChanged
|
||
);
|
||
require!(
|
||
args.version == old_record.record_number.saturating_add(1),
|
||
ErrCode::InvalidVersion
|
||
);
|
||
|
||
let expected_prev_hash = hash_unsigned_record(&old_record)?;
|
||
let provided_prev_hash = vec_to_hash32(&args.prev_hash)?;
|
||
require!(
|
||
expected_prev_hash == provided_prev_hash,
|
||
ErrCode::InvalidPrevHash
|
||
);
|
||
|
||
let new_balance = old_record
|
||
.blockchain
|
||
.paid_limit_bytes
|
||
.checked_add(args.additional_limit)
|
||
.ok_or(error!(ErrCode::MathOverflow))?;
|
||
require!(
|
||
new_balance >= old_record.blockchain.paid_limit_bytes,
|
||
ErrCode::BalanceDecrease
|
||
);
|
||
let old_used_bytes = old_record.blockchain.used_bytes;
|
||
let old_last_block_number = old_record.blockchain.last_block_number;
|
||
let blockchain_state_unchanged = old_record.blockchain.used_bytes == args.fields.used_bytes
|
||
&& old_record.blockchain.last_block_number == args.fields.last_block_number
|
||
&& old_record.blockchain.last_block_hash.as_slice() == args.fields.last_block_hash.as_slice()
|
||
&& old_record.blockchain.last_block_signature.as_slice()
|
||
== args.fields.last_block_signature.as_slice()
|
||
&& old_record.blockchain.arweave_tx_id == args.fields.arweave_tx_id;
|
||
|
||
let mut new_record = UserRecord {
|
||
created_at_ms: old_record.created_at_ms,
|
||
updated_at_ms: args.updated_at_ms,
|
||
record_number: args.version,
|
||
prev_record_hash: provided_prev_hash,
|
||
login: old_record.login.clone(),
|
||
root_key: old_record.root_key,
|
||
device_key: args.fields.device_key,
|
||
blockchain: BlockchainRecord {
|
||
blockchain_type: old_record.blockchain.blockchain_type,
|
||
blockchain_name: args.fields.blockchain_name.clone(),
|
||
blockchain_public_key: args.fields.blockchain_public_key,
|
||
paid_limit_bytes: new_balance,
|
||
used_bytes: args.fields.used_bytes,
|
||
last_block_number: args.fields.last_block_number,
|
||
last_block_hash: vec_to_hash32(&args.fields.last_block_hash)?,
|
||
last_block_signature: vec_to_signature(&args.fields.last_block_signature)?,
|
||
arweave_tx_id: args.fields.arweave_tx_id.clone(),
|
||
},
|
||
is_server: args.fields.is_server,
|
||
address_format_type: args.fields.address_format_type,
|
||
address_format_version: args.fields.address_format_version,
|
||
server_address: args.fields.server_address.clone(),
|
||
sync_servers: args.fields.sync_servers.clone(),
|
||
access_servers: args.fields.access_servers.clone(),
|
||
trusted_count: args.fields.trusted_count,
|
||
signature: [0; 64],
|
||
};
|
||
require!(
|
||
new_record.blockchain.blockchain_type == old_record.blockchain.blockchain_type
|
||
&& new_record.blockchain.blockchain_name == old_record.blockchain.blockchain_name
|
||
&& new_record.blockchain.blockchain_public_key
|
||
== old_record.blockchain.blockchain_public_key,
|
||
ErrCode::ImmutableFieldChanged
|
||
);
|
||
validate_blockchain_limits(
|
||
&new_record.blockchain,
|
||
old_used_bytes,
|
||
old_last_block_number,
|
||
false,
|
||
)?;
|
||
drop(old_record);
|
||
if !blockchain_state_unchanged {
|
||
verify_last_block_state_signature(&ctx.accounts.instructions, &new_record)?;
|
||
}
|
||
|
||
let unsigned = serialize_unsigned_record(&new_record)?;
|
||
new_record.signature = verify_record_signature(
|
||
&ctx.accounts.instructions,
|
||
&new_record.root_key,
|
||
&args.signature,
|
||
&unsigned,
|
||
)?;
|
||
drop(unsigned);
|
||
|
||
let serialized = serialize_full_record(&new_record)?;
|
||
ensure_pda_size_and_rent(
|
||
&ctx.accounts.user_pda,
|
||
&ctx.accounts.signer,
|
||
&ctx.accounts.system_program.to_account_info(),
|
||
serialized.len(),
|
||
)?;
|
||
write_to_pda(&ctx.accounts.user_pda, &serialized)?;
|
||
|
||
let topup_fee = limit_fee_lamports(args.additional_limit, economy.lamports_per_limit_step)?;
|
||
if topup_fee > 0 {
|
||
transfer_lamports(
|
||
&ctx.accounts.signer,
|
||
&ctx.accounts.inflow_vault,
|
||
&ctx.accounts.system_program.to_account_info(),
|
||
topup_fee,
|
||
)?;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn serialize_unsigned_record(record: &UserRecord) -> Result<Vec<u8>> {
|
||
let login_bytes = record.login.as_bytes();
|
||
require!(login_bytes.len() <= u8::MAX as usize, ErrCode::InvalidLogin);
|
||
|
||
let mut out = Vec::new();
|
||
out.extend_from_slice(MAGIC);
|
||
out.push(FORMAT_MAJOR);
|
||
out.push(FORMAT_MINOR);
|
||
out.extend_from_slice(&0u16.to_le_bytes());
|
||
|
||
out.extend_from_slice(&record.created_at_ms.to_le_bytes());
|
||
out.extend_from_slice(&record.updated_at_ms.to_le_bytes());
|
||
out.extend_from_slice(&record.record_number.to_le_bytes());
|
||
out.extend_from_slice(&record.prev_record_hash);
|
||
|
||
out.push(login_bytes.len() as u8);
|
||
out.extend_from_slice(login_bytes);
|
||
|
||
let blocks_count = if record.is_server { 6 } else { 5 };
|
||
out.push(blocks_count);
|
||
write_root_key_block(&mut out, record);
|
||
write_device_key_block(&mut out, record);
|
||
write_blockchain_registry_block(&mut out, &record.blockchain)?;
|
||
if record.is_server {
|
||
write_server_profile_block(&mut out, record)?;
|
||
}
|
||
write_access_servers_block(&mut out, record)?;
|
||
write_trusted_state_block(&mut out, record);
|
||
|
||
let record_len = out
|
||
.len()
|
||
.checked_add(64)
|
||
.ok_or(error!(ErrCode::MathOverflow))?;
|
||
require!(record_len <= u16::MAX as usize, ErrCode::RecordTooLarge);
|
||
let len_bytes = (record_len as u16).to_le_bytes();
|
||
out[7] = len_bytes[0];
|
||
out[8] = len_bytes[1];
|
||
|
||
Ok(out)
|
||
}
|
||
|
||
fn serialize_full_record(record: &UserRecord) -> Result<Vec<u8>> {
|
||
let mut out = serialize_unsigned_record(record)?;
|
||
out.extend_from_slice(&record.signature);
|
||
Ok(out)
|
||
}
|
||
|
||
fn write_root_key_block(out: &mut Vec<u8>, record: &UserRecord) {
|
||
out.push(BLOCK_TYPE_ROOT_KEY);
|
||
out.push(BLOCK_VERSION_0);
|
||
out.extend_from_slice(record.root_key.as_ref());
|
||
}
|
||
|
||
fn write_device_key_block(out: &mut Vec<u8>, record: &UserRecord) {
|
||
out.push(BLOCK_TYPE_DEVICE_KEY);
|
||
out.push(BLOCK_VERSION_0);
|
||
out.extend_from_slice(record.device_key.as_ref());
|
||
}
|
||
|
||
fn write_blockchain_registry_block(out: &mut Vec<u8>, blockchain: &BlockchainRecord) -> Result<()> {
|
||
out.push(BLOCK_TYPE_BLOCKCHAIN_REGISTRY);
|
||
out.push(BLOCK_VERSION_0);
|
||
out.push(1);
|
||
write_blockchain_record(out, blockchain)?;
|
||
Ok(())
|
||
}
|
||
|
||
fn write_blockchain_record(out: &mut Vec<u8>, blockchain: &BlockchainRecord) -> Result<()> {
|
||
out.push(blockchain.blockchain_type);
|
||
write_len_prefixed_string(out, &blockchain.blockchain_name)?;
|
||
out.extend_from_slice(blockchain.blockchain_public_key.as_ref());
|
||
out.extend_from_slice(&blockchain.paid_limit_bytes.to_le_bytes());
|
||
out.extend_from_slice(&blockchain.used_bytes.to_le_bytes());
|
||
out.extend_from_slice(&blockchain.last_block_number.to_le_bytes());
|
||
out.extend_from_slice(&blockchain.last_block_hash);
|
||
out.extend_from_slice(&blockchain.last_block_signature);
|
||
if blockchain.arweave_tx_id.is_empty() {
|
||
out.push(0);
|
||
} else {
|
||
out.push(1);
|
||
write_len_prefixed_string(out, &blockchain.arweave_tx_id)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn write_server_profile_block(out: &mut Vec<u8>, record: &UserRecord) -> Result<()> {
|
||
out.push(BLOCK_TYPE_SERVER_PROFILE);
|
||
out.push(BLOCK_VERSION_0);
|
||
out.push(1);
|
||
out.push(record.address_format_type);
|
||
out.push(record.address_format_version);
|
||
write_len_prefixed_string(out, &record.server_address)?;
|
||
require!(
|
||
record.sync_servers.len() <= MAX_SYNC_SERVERS,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
out.push(record.sync_servers.len() as u8);
|
||
for login in &record.sync_servers {
|
||
write_len_prefixed_string(out, login)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn write_access_servers_block(out: &mut Vec<u8>, record: &UserRecord) -> Result<()> {
|
||
out.push(BLOCK_TYPE_ACCESS_SERVERS);
|
||
out.push(BLOCK_VERSION_0);
|
||
require!(
|
||
record.access_servers.len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
out.push(record.access_servers.len() as u8);
|
||
for login in &record.access_servers {
|
||
write_len_prefixed_string(out, login)?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn write_trusted_state_block(out: &mut Vec<u8>, record: &UserRecord) {
|
||
out.push(BLOCK_TYPE_TRUSTED_STATE);
|
||
out.push(BLOCK_VERSION_0);
|
||
out.push(record.trusted_count);
|
||
}
|
||
|
||
fn write_len_prefixed_string(out: &mut Vec<u8>, value: &str) -> Result<()> {
|
||
let bytes = value.as_bytes();
|
||
require!(bytes.len() <= u8::MAX as usize, ErrCode::InvalidRecordData);
|
||
out.push(bytes.len() as u8);
|
||
out.extend_from_slice(bytes);
|
||
Ok(())
|
||
}
|
||
|
||
fn read_blockchain_record(data: &[u8], cursor: &mut usize) -> Result<BlockchainRecord> {
|
||
let blockchain_type = read_u8(data, cursor)?;
|
||
require!(
|
||
blockchain_type == BLOCKCHAIN_TYPE_MAIN_USER,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
let blockchain_name = read_len_prefixed_string(data, cursor)?;
|
||
let blockchain_public_key = Pubkey::new_from_array(read_fixed_32(data, cursor)?);
|
||
let paid_limit_bytes = read_u64(data, cursor)?;
|
||
let used_bytes = read_u64(data, cursor)?;
|
||
let last_block_number = read_u32(data, cursor)?;
|
||
let last_block_hash = read_fixed_32(data, cursor)?;
|
||
let last_block_signature = read_fixed_64(data, cursor)?;
|
||
let arweave_present = read_u8(data, cursor)?;
|
||
let arweave_tx_id = match arweave_present {
|
||
0 => String::new(),
|
||
1 => read_len_prefixed_string(data, cursor)?,
|
||
_ => return Err(error!(ErrCode::InvalidRecordData)),
|
||
};
|
||
Ok(BlockchainRecord {
|
||
blockchain_type,
|
||
blockchain_name,
|
||
blockchain_public_key,
|
||
paid_limit_bytes,
|
||
used_bytes,
|
||
last_block_number,
|
||
last_block_hash,
|
||
last_block_signature,
|
||
arweave_tx_id,
|
||
})
|
||
}
|
||
|
||
fn deserialize_record_from_pda(raw: &[u8]) -> Result<UserRecord> {
|
||
require!(raw.len() >= 9, ErrCode::InvalidRecordData);
|
||
require!(&raw[0..5] == MAGIC, ErrCode::InvalidRecordMagic);
|
||
require!(
|
||
raw[5] == FORMAT_MAJOR && raw[6] == FORMAT_MINOR,
|
||
ErrCode::InvalidRecordFormat
|
||
);
|
||
|
||
let record_len = u16::from_le_bytes([raw[7], raw[8]]) as usize;
|
||
require!(record_len >= 9 + 64, ErrCode::InvalidRecordLength);
|
||
require!(record_len <= raw.len(), ErrCode::InvalidRecordLength);
|
||
|
||
let useful = &raw[..record_len];
|
||
let mut cursor = 9usize;
|
||
|
||
let created_at_ms = read_u64(useful, &mut cursor)?;
|
||
let updated_at_ms = read_u64(useful, &mut cursor)?;
|
||
let record_number = read_u32(useful, &mut cursor)?;
|
||
let prev_record_hash = read_fixed_32(useful, &mut cursor)?;
|
||
let login = read_len_prefixed_string(useful, &mut cursor)?;
|
||
|
||
let blocks_count = read_u8(useful, &mut cursor)? as usize;
|
||
let mut root_key: Option<Pubkey> = None;
|
||
let mut device_key: Option<Pubkey> = None;
|
||
let mut blockchain: Option<BlockchainRecord> = None;
|
||
let mut is_server = false;
|
||
let mut address_format_type = 0u8;
|
||
let mut address_format_version = 0u8;
|
||
let mut server_address = String::new();
|
||
let mut sync_servers = Vec::new();
|
||
let mut access_servers = Vec::new();
|
||
let mut trusted_count = 0u8;
|
||
|
||
for _ in 0..blocks_count {
|
||
let block_type = read_u8(useful, &mut cursor)?;
|
||
let block_version = read_u8(useful, &mut cursor)?;
|
||
require!(
|
||
block_version == BLOCK_VERSION_0,
|
||
ErrCode::InvalidRecordFormat
|
||
);
|
||
match block_type {
|
||
BLOCK_TYPE_ROOT_KEY => {
|
||
require!(root_key.is_none(), ErrCode::InvalidRecordData);
|
||
root_key = Some(Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?));
|
||
}
|
||
BLOCK_TYPE_DEVICE_KEY => {
|
||
require!(device_key.is_none(), ErrCode::InvalidRecordData);
|
||
device_key = Some(Pubkey::new_from_array(read_fixed_32(useful, &mut cursor)?));
|
||
}
|
||
BLOCK_TYPE_BLOCKCHAIN_REGISTRY => {
|
||
require!(blockchain.is_none(), ErrCode::InvalidRecordData);
|
||
let count = read_u8(useful, &mut cursor)?;
|
||
require!(count == 1, ErrCode::InvalidRecordData);
|
||
blockchain = Some(read_blockchain_record(useful, &mut cursor)?);
|
||
}
|
||
BLOCK_TYPE_SERVER_PROFILE => {
|
||
require!(!is_server, ErrCode::InvalidRecordData);
|
||
is_server = read_u8(useful, &mut cursor)? == 1;
|
||
require!(is_server, ErrCode::InvalidRecordData);
|
||
address_format_type = read_u8(useful, &mut cursor)?;
|
||
address_format_version = read_u8(useful, &mut cursor)?;
|
||
server_address = read_len_prefixed_string(useful, &mut cursor)?;
|
||
let sync_count = read_u8(useful, &mut cursor)? as usize;
|
||
require!(sync_count <= MAX_SYNC_SERVERS, ErrCode::InvalidRecordData);
|
||
for _ in 0..sync_count {
|
||
sync_servers.push(read_len_prefixed_string(useful, &mut cursor)?);
|
||
}
|
||
}
|
||
BLOCK_TYPE_ACCESS_SERVERS => {
|
||
require!(access_servers.is_empty(), ErrCode::InvalidRecordData);
|
||
let access_count = read_u8(useful, &mut cursor)? as usize;
|
||
for _ in 0..access_count {
|
||
access_servers.push(read_len_prefixed_string(useful, &mut cursor)?);
|
||
}
|
||
}
|
||
BLOCK_TYPE_TRUSTED_STATE => {
|
||
trusted_count = read_u8(useful, &mut cursor)?;
|
||
}
|
||
_ => return Err(error!(ErrCode::InvalidRecordFormat)),
|
||
}
|
||
}
|
||
|
||
let signature = read_fixed_64(useful, &mut cursor)?;
|
||
require!(cursor == useful.len(), ErrCode::InvalidRecordLength);
|
||
|
||
Ok(UserRecord {
|
||
created_at_ms,
|
||
updated_at_ms,
|
||
record_number,
|
||
prev_record_hash,
|
||
login,
|
||
root_key: root_key.ok_or(error!(ErrCode::InvalidRecordData))?,
|
||
device_key: device_key.ok_or(error!(ErrCode::InvalidRecordData))?,
|
||
blockchain: blockchain.ok_or(error!(ErrCode::InvalidRecordData))?,
|
||
is_server,
|
||
address_format_type,
|
||
address_format_version,
|
||
server_address,
|
||
sync_servers,
|
||
access_servers,
|
||
trusted_count,
|
||
signature,
|
||
})
|
||
}
|
||
|
||
fn hash_unsigned_record(record: &UserRecord) -> Result<[u8; 32]> {
|
||
let unsigned = serialize_unsigned_record(record)?;
|
||
let digest = hashv(&[&unsigned]);
|
||
let mut out = [0u8; 32];
|
||
out.copy_from_slice(digest.as_ref());
|
||
Ok(out)
|
||
}
|
||
|
||
fn verify_record_signature(
|
||
instructions_sysvar: &AccountInfo,
|
||
root_key: &Pubkey,
|
||
signature: &[u8],
|
||
unsigned: &[u8],
|
||
) -> Result<[u8; 64]> {
|
||
let provided_sig = vec_to_signature(signature)?;
|
||
let msg_hash = hashv(&[unsigned]);
|
||
verify_ed25519_signature_instruction(
|
||
instructions_sysvar,
|
||
-2,
|
||
root_key,
|
||
&provided_sig,
|
||
msg_hash.as_ref(),
|
||
)?;
|
||
Ok(provided_sig)
|
||
}
|
||
|
||
fn verify_last_block_state_signature(
|
||
instructions_sysvar: &AccountInfo,
|
||
record: &UserRecord,
|
||
) -> Result<()> {
|
||
let message = serialize_last_block_state(record)?;
|
||
let msg_hash = hashv(&[&message]);
|
||
verify_ed25519_signature_instruction(
|
||
instructions_sysvar,
|
||
-1,
|
||
&record.blockchain.blockchain_public_key,
|
||
&record.blockchain.last_block_signature,
|
||
msg_hash.as_ref(),
|
||
)
|
||
}
|
||
|
||
fn verify_ed25519_signature_instruction(
|
||
instructions_sysvar: &AccountInfo,
|
||
index_relative_to_current: i64,
|
||
expected_pubkey: &Pubkey,
|
||
expected_signature: &[u8; 64],
|
||
expected_message: &[u8],
|
||
) -> Result<()> {
|
||
require_keys_eq!(
|
||
*instructions_sysvar.key,
|
||
anchor_lang::solana_program::sysvar::instructions::id(),
|
||
ErrCode::InvalidSignature
|
||
);
|
||
let ed_ix = get_instruction_relative(index_relative_to_current, instructions_sysvar)
|
||
.map_err(|_| error!(ErrCode::InvalidSignature))?;
|
||
require_keys_eq!(ed_ix.program_id, ed25519_program::id(), ErrCode::InvalidSignature);
|
||
let parsed = parse_ed25519_ix(ed_ix.data.as_slice())?;
|
||
require!(parsed.pubkey == *expected_pubkey, ErrCode::InvalidSignature);
|
||
require!(parsed.signature == *expected_signature, ErrCode::InvalidSignature);
|
||
require!(parsed.message == expected_message, ErrCode::InvalidSignature);
|
||
Ok(())
|
||
}
|
||
|
||
fn serialize_last_block_state(record: &UserRecord) -> Result<Vec<u8>> {
|
||
let mut out = Vec::new();
|
||
out.extend_from_slice(LAST_BLOCK_STATE_PREFIX);
|
||
write_len_prefixed_string(&mut out, &record.login)?;
|
||
write_len_prefixed_string(&mut out, &record.blockchain.blockchain_name)?;
|
||
out.extend_from_slice(&record.blockchain.last_block_number.to_le_bytes());
|
||
out.extend_from_slice(&record.blockchain.last_block_hash);
|
||
out.extend_from_slice(&record.blockchain.used_bytes.to_le_bytes());
|
||
Ok(out)
|
||
}
|
||
|
||
struct ParsedEd25519Ref<'a> {
|
||
pubkey: Pubkey,
|
||
signature: [u8; 64],
|
||
message: &'a [u8],
|
||
}
|
||
|
||
fn parse_ed25519_ix<'a>(data: &'a [u8]) -> Result<ParsedEd25519Ref<'a>> {
|
||
require!(data.len() >= 16, ErrCode::InvalidSignature);
|
||
require!(data[0] == 1, ErrCode::InvalidSignature);
|
||
|
||
let signature_offset = le_u16(data, 2)? as usize;
|
||
let signature_ix_index = le_u16(data, 4)?;
|
||
let pubkey_offset = le_u16(data, 6)? as usize;
|
||
let pubkey_ix_index = le_u16(data, 8)?;
|
||
let message_offset = le_u16(data, 10)? as usize;
|
||
let message_size = le_u16(data, 12)? as usize;
|
||
let message_ix_index = le_u16(data, 14)?;
|
||
|
||
require!(signature_ix_index == u16::MAX, ErrCode::InvalidSignature);
|
||
require!(pubkey_ix_index == u16::MAX, ErrCode::InvalidSignature);
|
||
require!(message_ix_index == u16::MAX, ErrCode::InvalidSignature);
|
||
|
||
let signature_end = signature_offset
|
||
.checked_add(64)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
let pubkey_end = pubkey_offset
|
||
.checked_add(32)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
let message_end = message_offset
|
||
.checked_add(message_size)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
|
||
let signature_slice = data
|
||
.get(signature_offset..signature_end)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
let pubkey_slice = data
|
||
.get(pubkey_offset..pubkey_end)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
let message = data
|
||
.get(message_offset..message_end)
|
||
.ok_or(error!(ErrCode::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(|_| error!(ErrCode::InvalidSignature))?,
|
||
);
|
||
|
||
Ok(ParsedEd25519Ref {
|
||
pubkey,
|
||
signature,
|
||
message,
|
||
})
|
||
}
|
||
|
||
fn le_u16(data: &[u8], offset: usize) -> Result<u16> {
|
||
let end = offset
|
||
.checked_add(2)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
let s = data
|
||
.get(offset..end)
|
||
.ok_or(error!(ErrCode::InvalidSignature))?;
|
||
Ok(u16::from_le_bytes([s[0], s[1]]))
|
||
}
|
||
|
||
fn validate_login(login: &str) -> Result<()> {
|
||
require!(!login.is_empty(), ErrCode::InvalidLogin);
|
||
require!(login.len() <= 20, ErrCode::InvalidLogin);
|
||
for ch in login.chars() {
|
||
if !(ch.is_ascii_alphabetic() || ch.is_ascii_digit() || ch == '_') {
|
||
return Err(error!(ErrCode::InvalidLogin));
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn login_seed_normalized(login: &str) -> String {
|
||
login.to_ascii_lowercase()
|
||
}
|
||
|
||
fn validate_fields(fields: &UserMutableFields) -> Result<()> {
|
||
require!(
|
||
!fields.blockchain_name.is_empty(),
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
fields.blockchain_name.as_bytes().len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
fields.last_block_hash.len() == 32 && fields.last_block_signature.len() == 64,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
fields.arweave_tx_id.as_bytes().len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
if fields.is_server {
|
||
require!(
|
||
!fields.server_address.is_empty(),
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
fields.server_address.as_bytes().len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
fields.sync_servers.len() <= MAX_SYNC_SERVERS,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
for login in &fields.sync_servers {
|
||
require!(!login.is_empty(), ErrCode::InvalidRecordData);
|
||
require!(
|
||
login.as_bytes().len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
}
|
||
} else {
|
||
require!(fields.server_address.is_empty(), ErrCode::InvalidRecordData);
|
||
require!(fields.sync_servers.is_empty(), ErrCode::InvalidRecordData);
|
||
}
|
||
require!(
|
||
fields.access_servers.len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
for login in &fields.access_servers {
|
||
require!(!login.is_empty(), ErrCode::InvalidRecordData);
|
||
require!(
|
||
login.as_bytes().len() <= u8::MAX as usize,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn validate_blockchain_limits(
|
||
blockchain: &BlockchainRecord,
|
||
old_used_bytes: u64,
|
||
old_last_block_number: u32,
|
||
is_create: bool,
|
||
) -> Result<()> {
|
||
require!(
|
||
blockchain.blockchain_type == BLOCKCHAIN_TYPE_MAIN_USER,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
require!(
|
||
blockchain.used_bytes <= blockchain.paid_limit_bytes,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
if !is_create {
|
||
require!(
|
||
blockchain.used_bytes >= old_used_bytes
|
||
&& blockchain.last_block_number >= old_last_block_number,
|
||
ErrCode::InvalidRecordData
|
||
);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn validate_inflow_vault(inflow_vault: &AccountInfo) -> Result<()> {
|
||
let payments_program_id = Pubkey::from_str(settings::SHINE_PAYMENTS_PROGRAM_ID)
|
||
.map_err(|_| error!(ErrCode::InvalidFeeReceiver))?;
|
||
let (expected, _) = Pubkey::find_program_address(
|
||
&[settings::SHINE_PAYMENTS_INFLOW_VAULT_SEED],
|
||
&payments_program_id,
|
||
);
|
||
require_keys_eq!(expected, *inflow_vault.key, ErrCode::InvalidFeeReceiver);
|
||
Ok(())
|
||
}
|
||
|
||
fn transfer_lamports<'info>(
|
||
payer: &AccountInfo<'info>,
|
||
recipient: &AccountInfo<'info>,
|
||
system_program: &AccountInfo<'info>,
|
||
lamports: u64,
|
||
) -> Result<()> {
|
||
if lamports == 0 {
|
||
return Ok(());
|
||
}
|
||
let ix = system_instruction::transfer(payer.key, recipient.key, lamports);
|
||
invoke(
|
||
&ix,
|
||
&[payer.clone(), recipient.clone(), system_program.clone()],
|
||
)?;
|
||
Ok(())
|
||
}
|
||
|
||
fn ensure_pda_size_and_rent<'info>(
|
||
pda: &AccountInfo<'info>,
|
||
payer: &AccountInfo<'info>,
|
||
system_program: &AccountInfo<'info>,
|
||
required_len: usize,
|
||
) -> Result<()> {
|
||
let current_len = pda.data_len();
|
||
if required_len <= current_len {
|
||
return Ok(());
|
||
}
|
||
|
||
let increase = required_len
|
||
.checked_sub(current_len)
|
||
.ok_or(error!(ErrCode::MathOverflow))?;
|
||
require!(
|
||
increase <= MAX_AUTO_REALLOC_INCREASE,
|
||
ErrCode::RecordTooLarge
|
||
);
|
||
|
||
let rent = Rent::get()?;
|
||
let required_lamports = rent.minimum_balance(required_len);
|
||
let current_lamports = pda.lamports();
|
||
let top_up = required_lamports.saturating_sub(current_lamports);
|
||
if top_up > 0 {
|
||
transfer_lamports(payer, pda, system_program, top_up)?;
|
||
}
|
||
|
||
pda.realloc(required_len, false)?;
|
||
Ok(())
|
||
}
|
||
|
||
fn limit_fee_lamports(limit_delta: u64, lamports_per_limit_step: u64) -> Result<u64> {
|
||
let units = limit_delta / settings::LIMIT_STEP;
|
||
units
|
||
.checked_mul(lamports_per_limit_step)
|
||
.ok_or(error!(ErrCode::MathOverflow))
|
||
}
|
||
|
||
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,
|
||
)
|
||
}
|
||
|
||
fn find_users_economy_config_pda(program_id: &Pubkey) -> (Pubkey, u8) {
|
||
Pubkey::find_program_address(&[settings::USERS_ECONOMY_CONFIG_SEED], program_id)
|
||
}
|
||
|
||
fn read_users_economy_config(pda: &AccountInfo) -> Result<UsersEconomyConfigState> {
|
||
let raw = safe_read_pda(pda);
|
||
require!(!raw.is_empty(), ErrCode::EmptyPdaData);
|
||
let mut slice: &[u8] = &raw;
|
||
UsersEconomyConfigState::deserialize(&mut slice)
|
||
.map_err(|_| error!(ErrCode::DeserializationError))
|
||
}
|
||
|
||
fn pad_to_fixed_size(mut bytes: Vec<u8>, target_size: usize) -> Result<Vec<u8>> {
|
||
require!(bytes.len() <= target_size, ErrCode::RecordTooLarge);
|
||
bytes.resize(target_size, 0);
|
||
Ok(bytes)
|
||
}
|
||
|
||
fn vec_to_signature(input: &[u8]) -> Result<[u8; 64]> {
|
||
require!(input.len() == 64, ErrCode::InvalidSignature);
|
||
let mut out = [0u8; 64];
|
||
out.copy_from_slice(input);
|
||
Ok(out)
|
||
}
|
||
|
||
fn vec_to_hash32(input: &[u8]) -> Result<[u8; 32]> {
|
||
require!(input.len() == 32, ErrCode::InvalidPrevHash);
|
||
let mut out = [0u8; 32];
|
||
out.copy_from_slice(input);
|
||
Ok(out)
|
||
}
|
||
|
||
fn read_u8(data: &[u8], cursor: &mut usize) -> Result<u8> {
|
||
let v = *data
|
||
.get(*cursor)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor += 1;
|
||
Ok(v)
|
||
}
|
||
|
||
fn read_u32(data: &[u8], cursor: &mut usize) -> Result<u32> {
|
||
let end = cursor
|
||
.checked_add(4)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
let slice = data
|
||
.get(*cursor..end)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor = end;
|
||
Ok(u32::from_le_bytes([slice[0], slice[1], slice[2], slice[3]]))
|
||
}
|
||
|
||
fn read_u64(data: &[u8], cursor: &mut usize) -> Result<u64> {
|
||
let end = cursor
|
||
.checked_add(8)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
let slice = data
|
||
.get(*cursor..end)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor = end;
|
||
Ok(u64::from_le_bytes([
|
||
slice[0], slice[1], slice[2], slice[3], slice[4], slice[5], slice[6], slice[7],
|
||
]))
|
||
}
|
||
|
||
fn read_fixed_32(data: &[u8], cursor: &mut usize) -> Result<[u8; 32]> {
|
||
let end = cursor
|
||
.checked_add(32)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
let slice = data
|
||
.get(*cursor..end)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor = end;
|
||
let mut out = [0u8; 32];
|
||
out.copy_from_slice(slice);
|
||
Ok(out)
|
||
}
|
||
|
||
fn read_fixed_64(data: &[u8], cursor: &mut usize) -> Result<[u8; 64]> {
|
||
let end = cursor
|
||
.checked_add(64)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
let slice = data
|
||
.get(*cursor..end)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor = end;
|
||
let mut out = [0u8; 64];
|
||
out.copy_from_slice(slice);
|
||
Ok(out)
|
||
}
|
||
|
||
fn read_len_prefixed_string(data: &[u8], cursor: &mut usize) -> Result<String> {
|
||
let len = read_u8(data, cursor)? as usize;
|
||
let end = cursor
|
||
.checked_add(len)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
let slice = data
|
||
.get(*cursor..end)
|
||
.ok_or(error!(ErrCode::InvalidRecordData))?;
|
||
*cursor = end;
|
||
let value = std::str::from_utf8(slice).map_err(|_| error!(ErrCode::InvalidRecordData))?;
|
||
Ok(value.to_string())
|
||
}
|