logos-blockchain/lssa
1
0
Fork 0
mirror of https://github.com/logos-blockchain/lssa.git synced 2026-01-07 15:53:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

fixed formatting and added overflow/underflow

Browse Source
This commit is contained in:
jonesmarvin8 2025-12-09 15:28:32 -05:00
parent 8c493a0155
commit 70c228dbec
1 changed files with 272 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

448
nssa/program_methods/guest/src/bin/token.rs
View File

@ -28,11 +28,13 @@ use nssa_core::{
// 4. Burn tokens from a Token Holding account (thus lowering total supply) // 4. Burn tokens from a Token Holding account (thus lowering total supply)
// Arguments to this function are: // Arguments to this function are:
// * Two accounts: [definition_account, holding_account]. // * Two accounts: [definition_account, holding_account].
// * Authorization required: holding_account
// * An instruction data byte string of length 23, indicating the balance to burn with the folloiwng layout // * An instruction data byte string of length 23, indicating the balance to burn with the folloiwng layout
// [0x03 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00]. // [0x03 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
// 5. Mint additional supply of tokens tokens to a Token Holding account (thus increasing total supply) // 5. Mint additional supply of tokens tokens to a Token Holding account (thus increasing total supply)
// Arguments to this function are: // Arguments to this function are:
// * Two accounts: [definition_account, holding_account]. // * Two accounts: [definition_account, holding_account].
// * Authorization required: definition_account
// * An instruction data byte string of length 23, indicating the balance to mint with the folloiwng layout // * An instruction data byte string of length 23, indicating the balance to mint with the folloiwng layout
// [0x04 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00]. // [0x04 || amount (little-endian 16 bytes) || 0x00 || 0x00 || 0x00 || 0x00 || 0x00 || 0x00].
@ -155,7 +157,7 @@ fn transfer(pre_states: &[AccountWithMetadata], balance_to_move: u128) -> Vec<Ac
recipient_holding.balance = recipient_holding recipient_holding.balance = recipient_holding
.balance .balance
.checked_add(balance_to_move) .checked_add(balance_to_move)
.expect("Recipient balance overflow."); .expect("Recipient balance overflow");
let sender_post = { let sender_post = {
let mut this = sender.account.clone(); let mut this = sender.account.clone();
@ -252,7 +254,6 @@ fn initialize_account(pre_states: &[AccountWithMetadata]) -> Vec<AccountPostStat
} }
fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<AccountPostState> { fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<AccountPostState> {
if pre_states.len() != 2 { if pre_states.len() != 2 {
panic!("Invalid number of accounts"); panic!("Invalid number of accounts");
} }
@ -262,8 +263,8 @@ fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<Accoun
let definition_values = let definition_values =
TokenDefinition::parse(&definition.account.data).expect("Definition account must be valid"); TokenDefinition::parse(&definition.account.data).expect("Definition account must be valid");
let user_values = let user_values = TokenHolding::parse(&user_holding.account.data)
TokenHolding::parse(&user_holding.account.data).expect("Token Holding account must be valid"); .expect("Token Holding account must be valid");
if definition.account_id != user_values.definition_id { if definition.account_id != user_values.definition_id {
panic!("Mismatch token definition and token holding"); panic!("Mismatch token definition and token holding");
@ -280,22 +281,20 @@ fn burn(pre_states: &[AccountWithMetadata], balance_to_burn: u128) -> Vec<Accoun
let mut post_user_holding = user_holding.account.clone(); let mut post_user_holding = user_holding.account.clone();
let mut post_definition = definition.account.clone(); let mut post_definition = definition.account.clone();
post_user_holding.data = TokenHolding::into_data( post_user_holding.data = TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: user_values.account_type,
account_type: user_values.account_type, definition_id: user_values.definition_id,
definition_id: user_values.definition_id, balance: user_values.balance - balance_to_burn,
balance: user_values.balance - balance_to_burn, });
}
);
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,
}
);
post_definition.data = TokenDefinition::into_data(TokenDefinition {
account_type: definition_values.account_type,
name: definition_values.name,
total_supply: definition_values
.total_supply
.checked_sub(balance_to_burn)
.expect("Total supply underflow"),
});
vec![ vec![
AccountPostState::new(post_definition), AccountPostState::new(post_definition),
@ -303,11 +302,14 @@ 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 { if pre_states.len() != 2 {
panic!("Invalid number of accounts"); panic!("Invalid number of accounts");
} }
let definition = &pre_states[0]; let definition = &pre_states[0];
let token_holding = &pre_states[1]; let token_holding = &pre_states[1];
@ -320,27 +322,32 @@ fn mint_additional_supply(pre_states: &[AccountWithMetadata], amount_to_mint: u1
let token_holding_values: TokenHolding = if token_holding.account == Account::default() { let token_holding_values: TokenHolding = if token_holding.account == Account::default() {
TokenHolding::new(&definition.account_id) 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 { if definition.account_id != token_holding_values.definition_id {
panic!("Mismatch token definition and token holding"); panic!("Mismatch token definition and token holding");
} }
let token_holding_post_data = TokenHolding { let token_holding_post_data = TokenHolding {
account_type: token_holding_values.account_type, account_type: token_holding_values.account_type,
definition_id: token_holding_values.definition_id, definition_id: token_holding_values.definition_id,
balance: token_holding_values.balance + amount_to_mint, balance: token_holding_values
.balance
.checked_add(amount_to_mint)
.expect("New balance overflow"),
}; };
let post_total_supply = definition_values let post_total_supply = definition_values
.total_supply .total_supply
.checked_add(amount_to_mint) .checked_add(amount_to_mint)
.expect("Total supply overflow"); .expect("Total supply overflow");
let post_definition_data = TokenDefinition { let post_definition_data = TokenDefinition {
account_type: definition_values.account_type, account_type: definition_values.account_type,
name: definition_values.name, name: definition_values.name,
total_supply: post_total_supply, total_supply: post_total_supply,
}; };
let post_definition = { let post_definition = {
@ -363,7 +370,6 @@ fn mint_additional_supply(pre_states: &[AccountWithMetadata], amount_to_mint: u1
vec![post_definition, token_holding_post] vec![post_definition, token_holding_post]
} }
type Instruction = [u8; 23]; type Instruction = [u8; 23];
fn main() { fn main() {
@ -449,9 +455,9 @@ mod tests {
use nssa_core::account::{Account, AccountId, AccountWithMetadata}; use nssa_core::account::{Account, AccountId, AccountWithMetadata};
use crate::{ use crate::{
TOKEN_DEFINITION_DATA_SIZE, TOKEN_HOLDING_DATA_SIZE, TOKEN_HOLDING_TYPE, TOKEN_DEFINITION_DATA_SIZE, TOKEN_DEFINITION_TYPE, TOKEN_HOLDING_DATA_SIZE,
TOKEN_DEFINITION_TYPE, TokenDefinition, TokenHolding, TOKEN_HOLDING_TYPE, TokenDefinition, TokenHolding, burn, initialize_account,
initialize_account, new_definition, transfer, burn, mint_additional_supply, mint_additional_supply, new_definition, transfer,
}; };
#[should_panic(expected = "Invalid number of input accounts")] #[should_panic(expected = "Invalid number of input accounts")]
@ -852,12 +858,14 @@ mod tests {
HoldingDiffDef, HoldingDiffDef,
HoldingSameDefAuth, HoldingSameDefAuth,
HoldingSameDefNotAuth, HoldingSameDefNotAuth,
HoldingSameDefNotAuthOverflow,
DefinitionAccountPostBurn, DefinitionAccountPostBurn,
HoldingAccountPostBurn, HoldingAccountPostBurn,
Uninit, Uninit,
InitMint, InitMint,
DefinitionAccountMint, DefinitionAccountMint,
HoldingSameDefMint, HoldingSameDefMint,
HoldingSameDefAuthLargeBalance,
} }
enum IdEnum { enum IdEnum {
@ -866,49 +874,45 @@ mod tests {
HoldingId, HoldingId,
} }
fn helper_account_constructor(selection: AccountsEnum) -> AccountWithMetadata{ fn helper_account_constructor(selection: AccountsEnum) -> AccountWithMetadata {
match selection { match selection {
AccountsEnum::DefinitionAccountAuth => AccountWithMetadata { AccountsEnum::DefinitionAccountAuth => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenDefinition::into_data( data: TokenDefinition::into_data(TokenDefinition {
TokenDefinition { account_type: TOKEN_DEFINITION_TYPE,
account_type: TOKEN_DEFINITION_TYPE, name: [2; 6],
name: [2; 6], total_supply: helper_balance_constructor(BalanceEnum::InitSupply),
total_supply: helper_balance_constructor(BalanceEnum::InitSupply), }),
}), nonce: 0,
nonce: 0,
}, },
is_authorized: true, is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId), account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
}, },
AccountsEnum::DefinitionAccountNotAuth => AccountWithMetadata { AccountsEnum::DefinitionAccountNotAuth => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32; 8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenDefinition::into_data( data: TokenDefinition::into_data(TokenDefinition {
TokenDefinition { account_type: TOKEN_DEFINITION_TYPE,
account_type: TOKEN_DEFINITION_TYPE, name: [2; 6],
name: [2; 6], total_supply: helper_balance_constructor(BalanceEnum::InitSupply),
total_supply: helper_balance_constructor(BalanceEnum::InitSupply), }),
}), nonce: 0,
nonce: 0,
}, },
is_authorized: false, is_authorized: false,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId), account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
}, },
AccountsEnum::HoldingDiffDef => AccountWithMetadata { AccountsEnum::HoldingDiffDef => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionIdDiff),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionIdDiff), balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance), }),
}
),
nonce: 0, nonce: 0,
}, },
is_authorized: true, is_authorized: true,
@ -916,15 +920,13 @@ mod tests {
}, },
AccountsEnum::HoldingSameDefAuth => AccountWithMetadata { AccountsEnum::HoldingSameDefAuth => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId), balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance), }),
}
),
nonce: 0, nonce: 0,
}, },
is_authorized: true, is_authorized: true,
@ -932,15 +934,27 @@ mod tests {
}, },
AccountsEnum::HoldingSameDefNotAuth => AccountWithMetadata { AccountsEnum::HoldingSameDefNotAuth => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId), balance: helper_balance_constructor(BalanceEnum::HoldingBalance),
balance: helper_balance_constructor(BalanceEnum::HoldingBalance), }),
} nonce: 0,
), },
is_authorized: false,
account_id: helper_id_constructor(IdEnum::HoldingId),
},
AccountsEnum::HoldingSameDefNotAuthOverflow => AccountWithMetadata {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::InitSupply),
}),
nonce: 0, nonce: 0,
}, },
is_authorized: false, is_authorized: false,
@ -948,30 +962,27 @@ mod tests {
}, },
AccountsEnum::DefinitionAccountPostBurn => AccountWithMetadata { AccountsEnum::DefinitionAccountPostBurn => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenDefinition::into_data( data: TokenDefinition::into_data(TokenDefinition {
TokenDefinition { account_type: TOKEN_DEFINITION_TYPE,
account_type: TOKEN_DEFINITION_TYPE, name: [2; 6],
name: [2; 6], total_supply: helper_balance_constructor(BalanceEnum::InitSupplyBurned),
total_supply: helper_balance_constructor(BalanceEnum::InitSupplyBurned), }),
}), nonce: 0,
nonce: 0,
}, },
is_authorized: true, is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId), account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
}, },
AccountsEnum::HoldingAccountPostBurn => AccountWithMetadata { AccountsEnum::HoldingAccountPostBurn => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId), balance: helper_balance_constructor(BalanceEnum::HoldingBalanceBurned),
balance: helper_balance_constructor(BalanceEnum::HoldingBalanceBurned), }),
}
),
nonce: 0, nonce: 0,
}, },
is_authorized: false, is_authorized: false,
@ -984,15 +995,13 @@ mod tests {
}, },
AccountsEnum::InitMint => AccountWithMetadata { AccountsEnum::InitMint => AccountWithMetadata {
account: Account { account: Account {
program_owner: [0u32;8], program_owner: [0u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId), balance: helper_balance_constructor(BalanceEnum::MintSuccess),
balance: helper_balance_constructor(BalanceEnum::MintSuccess), }),
}
),
nonce: 0, nonce: 0,
}, },
is_authorized: false, is_authorized: false,
@ -1000,36 +1009,47 @@ mod tests {
}, },
AccountsEnum::HoldingSameDefMint => AccountWithMetadata { AccountsEnum::HoldingSameDefMint => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenHolding::into_data( data: TokenHolding::into_data(TokenHolding {
TokenHolding { account_type: TOKEN_HOLDING_TYPE,
account_type: TOKEN_HOLDING_TYPE, definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId), balance: helper_balance_constructor(BalanceEnum::HoldingBalanceMint),
balance: helper_balance_constructor(BalanceEnum::HoldingBalanceMint), }),
} nonce: 0,
),
nonce: 0,
}, },
is_authorized: true, is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId), account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
}, },
AccountsEnum::DefinitionAccountMint => AccountWithMetadata { AccountsEnum::DefinitionAccountMint => AccountWithMetadata {
account: Account { account: Account {
program_owner: [5u32;8], program_owner: [5u32; 8],
balance: 0u128, balance: 0u128,
data: TokenDefinition::into_data( data: TokenDefinition::into_data(TokenDefinition {
TokenDefinition { account_type: TOKEN_DEFINITION_TYPE,
account_type: TOKEN_DEFINITION_TYPE, name: [2; 6],
name: [2; 6], total_supply: helper_balance_constructor(BalanceEnum::InitSupplyMint),
total_supply: helper_balance_constructor(BalanceEnum::InitSupplyMint), }),
}), nonce: 0,
nonce: 0,
}, },
is_authorized: true, is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId), account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
}, },
_ => panic!("Invalid selection") AccountsEnum::HoldingSameDefAuthLargeBalance => AccountWithMetadata {
account: Account {
program_owner: [5u32; 8],
balance: 0u128,
data: TokenHolding::into_data(TokenHolding {
account_type: TOKEN_HOLDING_TYPE,
definition_id: helper_id_constructor(IdEnum::PoolDefinitionId),
balance: helper_balance_constructor(BalanceEnum::MintOverflow),
}),
nonce: 0,
},
is_authorized: true,
account_id: helper_id_constructor(IdEnum::PoolDefinitionId),
},
_ => panic!("Invalid selection"),
} }
} }
@ -1045,152 +1065,228 @@ mod tests {
BalanceEnum::InitSupplyMint => 150_000, BalanceEnum::InitSupplyMint => 150_000,
BalanceEnum::HoldingBalanceMint => 51_000, BalanceEnum::HoldingBalanceMint => 51_000,
BalanceEnum::MintOverflow => (2 as u128).pow(128) - 40_000, BalanceEnum::MintOverflow => (2 as u128).pow(128) - 40_000,
_ => panic!("Invalid selection") _ => panic!("Invalid selection"),
} }
} }
fn helper_id_constructor(selection: IdEnum) -> AccountId { fn helper_id_constructor(selection: IdEnum) -> AccountId {
match selection { match selection {
IdEnum::PoolDefinitionId => AccountId::new([15;32]), IdEnum::PoolDefinitionId => AccountId::new([15; 32]),
IdEnum::PoolDefinitionIdDiff => AccountId::new([16;32]), IdEnum::PoolDefinitionIdDiff => AccountId::new([16; 32]),
IdEnum::HoldingId => AccountId::new([17;32]), IdEnum::HoldingId => AccountId::new([17; 32]),
} }
} }
#[test] #[test]
#[should_panic(expected = "Invalid number of accounts")] #[should_panic(expected = "Invalid number of accounts")]
fn test_burn_invalid_number_of_accounts() { fn test_burn_invalid_number_of_accounts() {
let pre_states = vec![ let pre_states = vec![helper_account_constructor(
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), AccountsEnum::DefinitionAccountAuth,
]; )];
let _post_states = burn(&pre_states, helper_balance_constructor(BalanceEnum::BurnSuccess)); let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::BurnSuccess),
);
} }
#[test] #[test]
#[should_panic(expected = "Mismatch token definition and token holding")] #[should_panic(expected = "Mismatch token definition and token holding")]
fn test_burn_mismatch_def() { fn test_burn_mismatch_def() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingDiffDef), 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] #[test]
#[should_panic(expected = "Authorization is missing")] #[should_panic(expected = "Authorization is missing")]
fn test_burn_missing_authorization() { fn test_burn_missing_authorization() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth), 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] #[test]
#[should_panic(expected = "Insufficient balance to burn")] #[should_panic(expected = "Insufficient balance to burn")]
fn test_burn_insufficient_balance() { fn test_burn_insufficient_balance() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefAuth), 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]
#[should_panic(expected = "Total supply underflow")]
fn test_burn_total_supply_underflow() {
let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefAuthLargeBalance),
];
let _post_states = burn(
&pre_states,
helper_balance_constructor(BalanceEnum::MintOverflow),
);
} }
#[test] #[test]
fn test_burn_success() { fn test_burn_success() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefAuth), 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 def_post = post_states[0].clone();
let holding_post = post_states[1].clone(); let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountPostBurn).account); assert!(
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::HoldingAccountPostBurn).account); *def_post.account()
== helper_account_constructor(AccountsEnum::DefinitionAccountPostBurn).account
);
assert!(
*holding_post.account()
== helper_account_constructor(AccountsEnum::HoldingAccountPostBurn).account
);
} }
#[test] #[test]
#[should_panic(expected = "Invalid number of accounts")] #[should_panic(expected = "Invalid number of accounts")]
fn test_mint_invalid_number_of_accounts() { fn test_mint_invalid_number_of_accounts() {
let pre_states = vec![ let pre_states = vec![helper_account_constructor(
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), AccountsEnum::DefinitionAccountAuth,
]; )];
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] #[test]
#[should_panic(expected = "Holding account must be valid")] #[should_panic(expected = "Holding account must be valid")]
fn test_mint_not_valid_holding_account() { fn test_mint_not_valid_holding_account() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::DefinitionAccountNotAuth), 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] #[test]
#[should_panic(expected = "Definition authorization is missing")] #[should_panic(expected = "Definition authorization is missing")]
fn test_mint_missing_authorization() { fn test_mint_missing_authorization() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountNotAuth), helper_account_constructor(AccountsEnum::DefinitionAccountNotAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth), 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] #[test]
#[should_panic(expected = "Mismatch token definition and token holding")] #[should_panic(expected = "Mismatch token definition and token holding")]
fn test_mint_mismatched_token_definition() { fn test_mint_mismatched_token_definition() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingDiffDef), 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] #[test]
fn test_mint_success() { fn test_mint_success() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth), 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 def_post = post_states[0].clone();
let holding_post = post_states[1].clone(); let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountMint).account); assert!(
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::HoldingSameDefMint).account); *def_post.account()
== helper_account_constructor(AccountsEnum::DefinitionAccountMint).account
);
assert!(
*holding_post.account()
== helper_account_constructor(AccountsEnum::HoldingSameDefMint).account
);
} }
#[test] #[test]
fn test_mint_uninit_holding_success() { fn test_mint_uninit_holding_success() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::Uninit), 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 def_post = post_states[0].clone();
let holding_post = post_states[1].clone(); let holding_post = post_states[1].clone();
assert!(*def_post.account() == helper_account_constructor(AccountsEnum::DefinitionAccountMint).account); assert!(
assert!(*holding_post.account() == helper_account_constructor(AccountsEnum::InitMint).account); *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); assert!(holding_post.requires_claim() == true);
} }
#[test] #[test]
#[should_panic(expected = "Total supply overflow.")] #[should_panic(expected = "Total supply overflow")]
fn test_mint_overflow() { fn test_mint_total_supply_overflow() {
let pre_states = vec![ let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth), helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth), helper_account_constructor(AccountsEnum::HoldingSameDefNotAuth),
]; ];
let _post_states = mint_additional_supply(&pre_states, let _post_states = mint_additional_supply(
helper_balance_constructor(BalanceEnum::MintOverflow)); &pre_states,
helper_balance_constructor(BalanceEnum::MintOverflow),
);
} }
} #[test]
#[should_panic(expected = "New balance overflow")]
fn test_mint_holding_account_overflow() {
let pre_states = vec![
helper_account_constructor(AccountsEnum::DefinitionAccountAuth),
helper_account_constructor(AccountsEnum::HoldingSameDefNotAuthOverflow),
];
let _post_states = mint_additional_supply(
&pre_states,
helper_balance_constructor(BalanceEnum::MintOverflow),
);
}
}