Skip to content

test(drive-abci): add happy path tests for token burn, freeze, emergency action, and destroy frozen funds #3459

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
QuantumExplorer merged 2 commits into from
Apr 9, 2026
Merged

test(drive-abci): add happy path tests for token burn, freeze, emergency action, and destroy frozen funds #3459

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
909a341
test(drive-abci): add happy path tests for token burn, freeze, emerge…
QuantumExplorer Apr 8, 2026
452498c
Merge branch 'v3.1-dev' into test/drive-abci-token-transitions
QuantumExplorer Apr 8, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
86 changes: 86 additions & 0 deletions ...src/execution/validation/state_transition/state_transitions/batch/tests/token/burn/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -90,6 +90,92 @@ mod token_burn_tests {
assert_eq!(token_balance, Some(expected_amount));
}

#[test]
fn test_token_burn_entire_balance() {
let platform_version = PlatformVersion::latest();
let mut platform = TestPlatformBuilder::new()
.with_latest_protocol_version()
.build_with_mock_rpc()
.set_genesis_state();

let mut rng = StdRng::seed_from_u64(49853);

let platform_state = platform.state.load();

let (identity, signer, key) =
setup_identity(&mut platform, rng.gen(), dash_to_credits!(0.5));

let (contract, token_id) = create_token_contract_with_owner_identity(
&mut platform,
identity.id(),
None::<fn(&mut TokenConfiguration)>,
None,
None,
None,
platform_version,
);

// Burn the entire balance of 100000 tokens
let burn_transition = BatchTransition::new_token_burn_transition(
token_id,
identity.id(),
contract.id(),
0,
100000,
None,
None,
&key,
2,
0,
&signer,
platform_version,
None,
)
.expect("expect to create documents batch transition");

let burn_serialized_transition = burn_transition
.serialize_to_bytes()
.expect("expected documents batch serialized state transition");

let transaction = platform.drive.grove.start_transaction();

let processing_result = platform
.platform
.process_raw_state_transitions(
&[burn_serialized_transition.clone()],
&platform_state,
&BlockInfo::default(),
&transaction,
platform_version,
false,
None,
)
.expect("expected to process state transition");

assert_matches!(
processing_result.execution_results().as_slice(),
[StateTransitionExecutionResult::SuccessfulExecution { .. }]
);

platform
.drive
.grove
.commit_transaction(transaction)
.unwrap()
.expect("expected to commit transaction");

let token_balance = platform
.drive
.fetch_identity_token_balance(
token_id.to_buffer(),
identity.id().to_buffer(),
None,
platform_version,
)
.expect("expected to fetch token balance");
assert_eq!(token_balance, Some(0));
}

#[test]
fn test_token_burn_trying_to_burn_more_than_we_have() {
let platform_version = PlatformVersion::latest();
Expand Down
257 changes: 257 additions & 0 deletions ...lidation/state_transition/state_transitions/batch/tests/token/destroy_frozen_funds/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,263 @@ use super::*;

mod token_destroy_frozen_funds_tests {
use super::*;
use dpp::tokens::info::v0::IdentityTokenInfoV0Accessors;

#[test]
fn test_token_destroy_frozen_funds_success() {
let platform_version = PlatformVersion::latest();
let mut platform = TestPlatformBuilder::new()
.with_latest_protocol_version()
.build_with_mock_rpc()
.set_genesis_state();

let mut rng = StdRng::seed_from_u64(49853);
let platform_state = platform.state.load();

let (identity, signer, key) =
setup_identity(&mut platform, rng.gen(), dash_to_credits!(0.5));

let (identity_2, _, _) = setup_identity(&mut platform, rng.gen(), dash_to_credits!(0.5));

let (contract, token_id) = create_token_contract_with_owner_identity(
&mut platform,
identity.id(),
Some(|token_configuration: &mut TokenConfiguration| {
token_configuration.set_destroy_frozen_funds_rules(ChangeControlRules::V0(
ChangeControlRulesV0 {
authorized_to_make_change: AuthorizedActionTakers::ContractOwner,
admin_action_takers: AuthorizedActionTakers::NoOne,
changing_authorized_action_takers_to_no_one_allowed: false,
changing_admin_action_takers_to_no_one_allowed: false,
self_changing_admin_action_takers_allowed: false,
},
));
token_configuration.set_freeze_rules(ChangeControlRules::V0(
ChangeControlRulesV0 {
authorized_to_make_change: AuthorizedActionTakers::ContractOwner,
admin_action_takers: AuthorizedActionTakers::NoOne,
changing_authorized_action_takers_to_no_one_allowed: false,
changing_admin_action_takers_to_no_one_allowed: false,
self_changing_admin_action_takers_allowed: false,
},
));
token_configuration.set_manual_minting_rules(ChangeControlRules::V0(
ChangeControlRulesV0 {
authorized_to_make_change: AuthorizedActionTakers::ContractOwner,
admin_action_takers: AuthorizedActionTakers::NoOne,
changing_authorized_action_takers_to_no_one_allowed: false,
changing_admin_action_takers_to_no_one_allowed: false,
self_changing_admin_action_takers_allowed: false,
},
));
token_configuration
.distribution_rules_mut()
.set_minting_allow_choosing_destination(true);
}),
None,
None,
None,
platform_version,
);

// Mint tokens to identity_2
let mint_transition = BatchTransition::new_token_mint_transition(
token_id,
identity.id(),
contract.id(),
0,
5000,
Some(identity_2.id()),
None,
None,
&key,
2,
0,
&signer,
platform_version,
None,
)
.expect("expected to create mint transition");

let serialized = mint_transition
.serialize_to_bytes()
.expect("expected to serialize");

let transaction = platform.drive.grove.start_transaction();

let processing_result = platform
.platform
.process_raw_state_transitions(
&[serialized],
&platform_state,
&BlockInfo::default(),
&transaction,
platform_version,
false,
None,
)
.expect("expected to process state transition");

assert_matches!(
processing_result.execution_results().as_slice(),
[StateTransitionExecutionResult::SuccessfulExecution { .. }]
);

platform
.drive
.grove
.commit_transaction(transaction)
.unwrap()
.expect("expected to commit transaction");

// Verify identity_2 has the minted tokens
let token_balance = platform
.drive
.fetch_identity_token_balance(
token_id.to_buffer(),
identity_2.id().to_buffer(),
None,
platform_version,
)
.expect("expected to fetch token balance");
assert_eq!(token_balance, Some(5000));

// Freeze identity_2's token account
let freeze_transition = BatchTransition::new_token_freeze_transition(
token_id,
identity.id(),
contract.id(),
0,
identity_2.id(),
None,
None,
&key,
3,
0,
&signer,
platform_version,
None,
)
.expect("expected to create freeze transition");

let serialized = freeze_transition
.serialize_to_bytes()
.expect("expected to serialize");

let transaction = platform.drive.grove.start_transaction();

let processing_result = platform
.platform
.process_raw_state_transitions(
&[serialized],
&platform_state,
&BlockInfo::default(),
&transaction,
platform_version,
false,
None,
)
.expect("expected to process state transition");

assert_matches!(
processing_result.execution_results().as_slice(),
[StateTransitionExecutionResult::SuccessfulExecution { .. }]
);

platform
.drive
.grove
.commit_transaction(transaction)
.unwrap()
.expect("expected to commit transaction");

// Verify identity_2 is frozen
let token_frozen = platform
.drive
.fetch_identity_token_info(
token_id.to_buffer(),
identity_2.id().to_buffer(),
None,
platform_version,
)
.expect("expected to fetch token info")
.map(|info| info.frozen());
assert_eq!(token_frozen, Some(true));

// Destroy the frozen funds
let destroy_transition = BatchTransition::new_token_destroy_frozen_funds_transition(
token_id,
identity.id(),
contract.id(),
0,
identity_2.id(),
None,
None,
&key,
4,
0,
&signer,
platform_version,
None,
)
.expect("expected to create destroy frozen funds transition");

let serialized = destroy_transition
.serialize_to_bytes()
.expect("expected to serialize");

let transaction = platform.drive.grove.start_transaction();

let processing_result = platform
.platform
.process_raw_state_transitions(
&[serialized],
&platform_state,
&BlockInfo::default(),
&transaction,
platform_version,
false,
None,
)
.expect("expected to process state transition");

assert_matches!(
processing_result.execution_results().as_slice(),
[StateTransitionExecutionResult::SuccessfulExecution { .. }]
);

platform
.drive
.grove
.commit_transaction(transaction)
.unwrap()
.expect("expected to commit transaction");

// Verify the frozen funds were destroyed (balance should be 0)
let token_balance = platform
.drive
.fetch_identity_token_balance(
token_id.to_buffer(),
identity_2.id().to_buffer(),
None,
platform_version,
)
.expect("expected to fetch token balance");
assert_eq!(token_balance, Some(0));

// Verify identity_2 is still frozen
let token_frozen = platform
.drive
.fetch_identity_token_info(
token_id.to_buffer(),
identity_2.id().to_buffer(),
None,
platform_version,
)
.expect("expected to fetch token info")
.map(|info| info.frozen());
assert_eq!(token_frozen, Some(true));
}

#[test]
fn test_token_destroy_frozen_funds_on_unfrozen_account_should_fail() {
Expand Down
Loading
Loading