This commit is contained in:
jonesmarvin8 2025-12-09 15:36:46 -05:00
parent 471611f848
commit 2e37e20014

View File

@ -252,7 +252,6 @@ fn initialize_account(pre_states: &[AccountWithMetadata]) -> Vec<AccountPostStat
}
fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<AccountPostState> {
if pre_states.len() != 2 {
panic!("Invalid number of accounts");
}
@ -262,8 +261,8 @@ fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<Accoun
let definition_values =
TokenDefinition::parse(&definition.account.data).expect("Definition account must be valid");
let user_values =
TokenHolding::parse(&user_holding.account.data).expect("Token Holding account must be valid");
let user_values = TokenHolding::parse(&user_holding.account.data)
.expect("Token Holding account must be valid");
if definition.account_id != user_values.definition_id {
panic!("Mismatch token definition and token holding");
@ -280,22 +279,17 @@ fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<Accoun
let mut post_user_holding = user_holding.account.clone();
let mut post_definition = definition.account.clone();
post_user_holding.data = TokenHolding::into_data(
TokenHolding {
post_user_holding.data = TokenHolding::into_data(TokenHolding {
account_type: user_values.account_type,
definition_id: user_values.definition_id,
balance: user_values.balance - balance_to_burn,
}
);
});
post_definition.data = TokenDefinition::into_data(
TokenDefinition {
post_definition.data = TokenDefinition::into_data(TokenDefinition {
account_type: definition_values.account_type,
name: definition_values.name,
total_supply: definition_values.total_supply - balance_to_burn,
}
);
});
vec![
AccountPostState::new(post_definition),
@ -303,7 +297,10 @@ fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<Accoun
]
}
fn mint_additional_supply(pre_states: &[AccountWithMetadata], amount_to_mint: u128) -> Vec<AccountPostState> {
fn mint_additional_supply(
pre_states: &[AccountWithMetadata],
amount_to_mint: u128,
) -> Vec<AccountPostState> {
if pre_states.len() != 2 {
panic!("Invalid number of accounts");
}
@ -323,7 +320,9 @@ fn mint_additional_supply(pre_states: &[AccountWithMetadata], amount_to_mint: u1
let token_holding_values: TokenHolding = if token_holding.account == Account::default() {
TokenHolding::new(&definition.account_id)
} else { TokenHolding::parse(&token_holding.account.data).expect("Holding account must be valid") };
} else {
TokenHolding::parse(&token_holding.account.data).expect("Holding account must be valid")
};
if definition.account_id != token_holding_values.definition_id {
panic!("Mismatch token definition and token holding");
@ -361,7 +360,6 @@ fn mint_additional_supply(pre_states: &[AccountWithMetadata], amount_to_mint: u1
vec![post_definition, token_holding_post]
}
type Instruction = [u8; 23];
fn main() {
@ -447,9 +445,9 @@ mod tests {
use nssa_core::account::{Account, AccountId, AccountWithMetadata};
use crate::{
TOKEN_DEFINITION_DATA_SIZE, TOKEN_HOLDING_DATA_SIZE, TOKEN_HOLDING_TYPE,
TOKEN_DEFINITION_TYPE, TokenDefinition, TokenHolding,
initialize_account, new_definition, transfer, burn, mint_additional_supply,
TOKEN_DEFINITION_DATA_SIZE, TOKEN_DEFINITION_TYPE, TOKEN_HOLDING_DATA_SIZE,
TOKEN_HOLDING_TYPE, TokenDefinition, TokenHolding, burn, initialize_account,
mint_additional_supply, new_definition, transfer,
};
#[should_panic(expected = "Invalid number of input accounts")]
@ -869,8 +867,7 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenDefinition::into_data(
TokenDefinition {
data: TokenDefinition::into_data(TokenDefinition {
account_type: TOKEN_DEFINITION_TYPE,
name: [2; 6],
total_supply: helper_balance_constructor(BalanceEnum::InitSupply),
@ -884,8 +881,7 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenDefinition::into_data(
TokenDefinition {
data: TokenDefinition::into_data(TokenDefinition {
account_type: TOKEN_DEFINITION_TYPE,
name: [2; 6],
total_supply: helper_balance_constructor(BalanceEnum::InitSupply),
@ -899,13 +895,11 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionIdDiff),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
}
),
}),
nonce: 0,
},
is_authorized: true,
@ -915,13 +909,11 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
}
),
}),
nonce: 0,
},
is_authorized: true,
@ -931,13 +923,11 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
}
),
}),
nonce: 0,
},
is_authorized: false,
@ -947,8 +937,7 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenDefinition::into_data(
TokenDefinition {
data: TokenDefinition::into_data(TokenDefinition {
account_type: TOKEN_DEFINITION_TYPE,
name: [2; 6],
total_supply: helper_balance_constructor(BalanceEnum::InitSupplyBurned),
@ -962,13 +951,11 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::HoldingBalanceBurned),
}
),
}),
nonce: 0,
},
is_authorized: false,
@ -983,13 +970,11 @@ mod tests {
account: Account {
program_owner: [0u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::MintSuccess),
}
),
}),
nonce: 0,
},
is_authorized: false,
@ -999,13 +984,11 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(
TokenHolding {
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::HoldingBalanceMint),
}
),
}),
nonce: 0,
},
is_authorized: true,
@ -1015,8 +998,7 @@ mod tests {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenDefinition::into_data(
TokenDefinition {
data: TokenDefinition::into_data(TokenDefinition {
account_type: TOKEN_DEFINITION_TYPE,
name: [2; 6],
total_supply: helper_balance_constructor(BalanceEnum::InitSupplyMint),
@ -1026,7 +1008,7 @@ mod tests {
is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
},
_ => panic!("Invalid selection")
_ => panic!("Invalid selection"),
}
}
@ -1041,7 +1023,7 @@ mod tests {
BalanceEnum::MintSuccess => 50_000,
BalanceEnum::InitSupplyMint => 150_000,
BalanceEnum::HoldingBalanceMint => 51_000,
_ => panic!("Invalid selection")
_ => panic!("Invalid selection"),
}
}
@ -1056,10 +1038,13 @@ mod tests {
#[test]
#[should_panic(expected = "Invalid number of accounts")]
fn test_burn_invalid_number_of_accounts() {
let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
];
let _post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnSuccess));
let pre_states = vec![helper_account_constructor(
AccountsEnum::DefinitionAccountAuth,
)];
let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnSuccess),
);
}
#[test]
@ -1069,7 +1054,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingDiffDef),
];
let _post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnSuccess));
let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnSuccess),
);
}
#[test]
@ -1079,7 +1067,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth),
];
let _post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnSuccess));
let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnSuccess),
);
}
#[test]
@ -1089,7 +1080,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefAuth),
];
let _post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnInsufficient));
let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnInsufficient),
);
}
#[test]
@ -1098,22 +1092,34 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefAuth),
];
let post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnSuccess));
let post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnSuccess),
);
let def_post = post_states[0].clone();
let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountPostBurn).account);
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::HoldingAccountPostBurn).account);
assert!(
*def_post.account()
== helper_account_constructor(AccountsEnum::DefinitionAccountPostBurn).account
);
assert!(
*holding_post.account()
== helper_account_constructor(AccountsEnum::HoldingAccountPostBurn).account
);
}
#[test]
#[should_panic(expected = "Invalid number of accounts")]
fn test_mint_invalid_number_of_accounts() {
let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
];
let _post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let pre_states = vec![helper_account_constructor(
AccountsEnum::DefinitionAccountAuth,
)];
let _post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
}
#[test]
@ -1123,7 +1129,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::DefinitionAccountNotAuth),
];
let _post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let _post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
}
#[test]
@ -1133,7 +1142,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountNotAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth),
];
let _post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let _post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
}
#[test]
@ -1143,7 +1155,10 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingDiffDef),
];
let _post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let _post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
}
#[test]
@ -1152,13 +1167,22 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth),
];
let post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
let def_post = post_states[0].clone();
let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountMint).account);
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::HoldingSameDefMint).account);
assert!(
*def_post.account()
== helper_account_constructor(AccountsEnum::DefinitionAccountMint).account
);
assert!(
*holding_post.account()
== helper_account_constructor(AccountsEnum::HoldingSameDefMint).account
);
}
#[test]
@ -1167,14 +1191,21 @@ mod tests {
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::Uninit),
];
let post_states = mint_additional_supply(&pre_states, helper_balance_constructor(BalanceEnum::MintSuccess));
let post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintSuccess),
);
let def_post = post_states[0].clone();
let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountMint).account);
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::InitMint).account);
assert!(
*def_post.account()
== helper_account_constructor(AccountsEnum::DefinitionAccountMint).account
);
assert!(
*holding_post.account() == helper_account_constructor(AccountsEnum::InitMint).account
);
assert!(holding_post.requires_claim() == true);
}
}