montana/Монтана-Протокол/Код/crates/mt-account/tests/determinism_invariants.rs

// Automated determinism invariants для mt-account.
// M3 audit prep — operation processing layer; любое non-determinism
// = consensus fork. Invariants ловят regression если refactor случайно
// ломает byte-exact apply semantics, op_hash stability, либо state
// transition determinism.

use mt_account::{
    apply, apply_anchor, apply_change_key, apply_proposal, apply_transfer, build_genesis_state,
    op_hash, reward_moneta, settle_window, supply_moneta, validate_transfer, Anchor, ChangeKey,
    Operation, ProposalSettle, Transfer, TransferActivation, ANCHOR_SIZE, CHANGE_KEY_SIZE,
    GENESIS_SUITE_ID, TRANSFER_ACTIVATION_SIZE, TRANSFER_SIZE, TYPE_ANCHOR, TYPE_CHANGE_KEY,
    TYPE_TRANSFER, TYPE_TRANSFER_ACTIVATION,
};
use mt_codec::CanonicalEncode;
use mt_crypto::{PublicKey, Signature, PUBLIC_KEY_SIZE, SIGNATURE_SIZE};
use mt_state::{derive_account_id, derive_node_id, AccountRecord, AccountTable};

// ---------- Helpers ----------

fn sample_account(id_byte: u8, balance: u128) -> AccountRecord {
    AccountRecord {
        account_id: [id_byte; 32],
        balance,
        suite_id: 1,
        is_node_operator: false,
        frontier_hash: [0xBB; 32],
        op_height: 0,
        account_chain_length: 0,
        account_chain_length_snapshot: 0,
        current_pubkey: [0xCC; PUBLIC_KEY_SIZE],
        creation_window: 0,
        last_op_window: 0,
        last_activation_window: 0,
    }
}

fn sample_transfer(sender: [u8; 32], link: [u8; 32], amount: u128) -> Transfer {
    Transfer {
        prev_hash: [0xBB; 32],
        sender,
        link,
        amount,
        signature: Signature::from_array([0u8; SIGNATURE_SIZE]),
    }
}

fn sample_anchor(sender: [u8; 32]) -> Anchor {
    Anchor {
        prev_hash: [0xBB; 32],
        sender,
        app_id: [0x11; 32],
        data_hash: [0x22; 32],
        signature: Signature::from_array([0u8; SIGNATURE_SIZE]),
    }
}

fn sample_change_key(sender: [u8; 32]) -> ChangeKey {
    ChangeKey {
        prev_hash: [0xBB; 32],
        sender,
        new_suite_id: 1,
        new_pubkey: PublicKey::from_array([0xDD; PUBLIC_KEY_SIZE]),
        signature: Signature::from_array([0u8; SIGNATURE_SIZE]),
    }
}

// ---------- Encoded sizes match constants ([I-9] determinism) ----------

#[test]
fn transfer_encoded_size_constant() {
    let mut buf = Vec::new();
    sample_transfer([0x01; 32], [0x02; 32], 100).encode(&mut buf);
    assert_eq!(
        buf.len(),
        TRANSFER_SIZE,
        "Transfer encoded size drift: expected {}, got {}",
        TRANSFER_SIZE,
        buf.len()
    );
}

#[test]
fn change_key_encoded_size_constant() {
    let mut buf = Vec::new();
    sample_change_key([0x01; 32]).encode(&mut buf);
    assert_eq!(buf.len(), CHANGE_KEY_SIZE);
}

#[test]
fn anchor_encoded_size_constant() {
    let mut buf = Vec::new();
    sample_anchor([0x01; 32]).encode(&mut buf);
    assert_eq!(buf.len(), ANCHOR_SIZE);
}

#[test]
fn transfer_activation_encoded_size_constant() {
    let op = TransferActivation {
        prev_hash: [0xBB; 32],
        sender: [0x01; 32],
        receiver: [0x02; 32],
        suite_id: 1,
        receiver_pubkey: PublicKey::from_array([0xCC; PUBLIC_KEY_SIZE]),
        amount: 100,
        signature: Signature::from_array([0u8; SIGNATURE_SIZE]),
    };
    let mut buf = Vec::new();
    op.encode(&mut buf);
    assert_eq!(buf.len(), TRANSFER_ACTIVATION_SIZE);
}

// ---------- Type byte stability (consensus type codes) ----------

#[test]
fn type_codes_stable() {
    // SSOT [I-10]: type codes immutable. Изменение = consensus fork.
    assert_eq!(TYPE_TRANSFER, 0x02);
    assert_eq!(TYPE_CHANGE_KEY, 0x03);
    assert_eq!(TYPE_ANCHOR, 0x04);
    assert_eq!(TYPE_TRANSFER_ACTIVATION, 0x0A);
}

// ---------- op_hash determinism (R2 invariant) ----------

#[test]
fn op_hash_deterministic_transfer() {
    let op = Operation::Transfer(sample_transfer([0x01; 32], [0x02; 32], 100));
    assert_eq!(op_hash(&op), op_hash(&op));
}

#[test]
fn op_hash_stable_under_signature_mutation() {
    // R2: identifier(op) = SHA-256("mt-op" || signed_scope(op)) — signature
    // НЕ входит в hash. Защита от schemes where signature randomized.
    let t1 = sample_transfer([0x01; 32], [0x02; 32], 100);
    let mut t2 = t1.clone();
    t2.signature = Signature::from_array([0xFF; SIGNATURE_SIZE]);
    let op1 = Operation::Transfer(t1);
    let op2 = Operation::Transfer(t2);
    assert_eq!(op_hash(&op1), op_hash(&op2));
}

#[test]
fn op_hash_changes_on_field_mutation() {
    let base = Operation::Transfer(sample_transfer([0x01; 32], [0x02; 32], 100));
    let mutated_amount = Operation::Transfer(sample_transfer([0x01; 32], [0x02; 32], 101));
    let mutated_sender = Operation::Transfer(sample_transfer([0xAA; 32], [0x02; 32], 100));
    let mutated_link = Operation::Transfer(sample_transfer([0x01; 32], [0xBB; 32], 100));
    assert_ne!(op_hash(&base), op_hash(&mutated_amount));
    assert_ne!(op_hash(&base), op_hash(&mutated_sender));
    assert_ne!(op_hash(&base), op_hash(&mutated_link));
}

#[test]
fn op_hash_distinct_across_op_types() {
    // Type byte должен различать operations даже если поля совпадают.
    let t = Operation::Transfer(sample_transfer([0x01; 32], [0x02; 32], 100));
    let a = Operation::Anchor(sample_anchor([0x01; 32]));
    let c = Operation::ChangeKey(sample_change_key([0x01; 32]));
    assert_ne!(op_hash(&t), op_hash(&a));
    assert_ne!(op_hash(&t), op_hash(&c));
    assert_ne!(op_hash(&a), op_hash(&c));
}

// ---------- apply_* determinism (state transition) ----------

#[test]
fn apply_transfer_deterministic() {
    let mut state1 = AccountTable::new();
    state1.insert(sample_account(0xAA, 1_000_000));
    state1.insert(sample_account(0xBB, 0));
    let mut state2 = state1.clone();

    // Set frontier_hash to match what validate_transfer expects (sample's prev_hash)
    let mut s_acct = state1.get(&[0xAA; 32]).unwrap().clone();
    s_acct.frontier_hash = [0xBB; 32]; // matches sample_transfer.prev_hash
    state1.insert(s_acct.clone());
    state2.insert(s_acct);

    let op = sample_transfer([0xAA; 32], [0xBB; 32], 1000);
    apply_transfer(&op, &mut state1, 5);
    apply_transfer(&op, &mut state2, 5);
    assert_eq!(state1.root(), state2.root());
}

#[test]
fn apply_anchor_does_not_change_balance() {
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);

    let op = sample_anchor([0xAA; 32]);
    let balance_before = state.get(&[0xAA; 32]).unwrap().balance;
    apply_anchor(&op, &mut state, 5);
    let balance_after = state.get(&[0xAA; 32]).unwrap().balance;
    assert_eq!(balance_before, balance_after, "Anchor не меняет balance");
}

#[test]
fn apply_change_key_updates_pubkey() {
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);

    let op = sample_change_key([0xAA; 32]);
    apply_change_key(&op, &mut state, 5);
    let updated = state.get(&[0xAA; 32]).unwrap();
    assert_eq!(updated.current_pubkey, [0xDD; PUBLIC_KEY_SIZE]);
}

// ---------- Validation determinism ----------

#[test]
fn validate_rejects_self_transfer() {
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    // Insert receiver
    state.insert(sample_account(0xCC, 0));

    let op = sample_transfer([0xAA; 32], [0xAA; 32], 100);
    assert!(validate_transfer(&op, &state).is_err());
}

#[test]
fn validate_rejects_zero_amount() {
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    state.insert(sample_account(0xBB, 0));

    let op = sample_transfer([0xAA; 32], [0xBB; 32], 0);
    assert!(validate_transfer(&op, &state).is_err());
}

#[test]
fn validate_rejects_insufficient_balance() {
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 100);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    state.insert(sample_account(0xBB, 0));

    let op = sample_transfer([0xAA; 32], [0xBB; 32], 1000); // более чем balance
    assert!(validate_transfer(&op, &state).is_err());
}

// ---------- settle_window determinism (op_hash sort order) ----------

#[test]
fn settle_window_op_order_independent() {
    // settle_window sorts by op_hash — порядок входа не влияет на итог.
    let mut state1 = AccountTable::new();
    let mut acct_aa = sample_account(0xAA, 1_000_000);
    acct_aa.frontier_hash = [0xBB; 32];
    state1.insert(acct_aa.clone());
    state1.insert(sample_account(0xCC, 0));
    state1.insert(sample_account(0xDD, 0));
    let mut state2 = state1.clone();

    let op_a = Operation::Transfer(sample_transfer([0xAA; 32], [0xCC; 32], 100));
    let op_b = Operation::Transfer(sample_transfer([0xAA; 32], [0xDD; 32], 200));

    // Note: после первого apply, frontier меняется → второй op fails validate
    // (prev_hash mismatch). Но settle_window не вызывает validate; смотрим
    // только что order-independence сохраняется на уровне sort+apply
    // (skipping validation gates за scope теста).
    settle_window(&mut state1, &[op_a.clone(), op_b.clone()], 5);
    settle_window(&mut state2, &[op_b, op_a], 5);

    // После sort'ов by op_hash — оба state равны.
    assert_eq!(state1.root(), state2.root());
}

// ---------- Genesis state determinism ----------

#[test]
fn build_genesis_state_deterministic() {
    let p = mt_genesis::genesis_params();
    let g1 = build_genesis_state(p);
    let g2 = build_genesis_state(p);
    assert_eq!(g1.account_table.root(), g2.account_table.root());
    assert_eq!(g1.node_table.root(), g2.node_table.root());
    assert_eq!(g1.candidate_pool.root(), g2.candidate_pool.root());
}

#[test]
fn genesis_supply_zero() {
    // spec: Genesis State до первого окна — supply = 0.
    let p = mt_genesis::genesis_params();
    let g = build_genesis_state(p);
    let total: u128 = g.account_table.iter().map(|r| r.balance).sum();
    assert_eq!(total, 0);
}

#[test]
fn genesis_node_chain_length_is_one() {
    // spec invariant: chain_length ≥ 1 для любого узла, включая genesis bootstrap.
    let p = mt_genesis::genesis_params();
    let g = build_genesis_state(p);
    let node_id = derive_node_id(&p.bootstrap_node_pubkey);
    let node = g.node_table.get(&node_id).expect("genesis node");
    assert_eq!(node.chain_length, 1);
}

// ---------- reward_moneta + supply_moneta consistency ----------

#[test]
fn reward_moneta_returns_emission_const() {
    let p = mt_genesis::genesis_params();
    assert_eq!(reward_moneta(p), p.emission_moneta);
}

#[test]
fn supply_moneta_window_zero_is_emission() {
    let p = mt_genesis::genesis_params();
    assert_eq!(supply_moneta(0, p), p.emission_moneta);
}

#[test]
fn supply_moneta_grows_linearly() {
    let p = mt_genesis::genesis_params();
    let s0 = supply_moneta(0, p);
    let s10 = supply_moneta(10, p);
    let s100 = supply_moneta(100, p);
    assert!(s0 < s10);
    assert!(s10 < s100);
    assert_eq!(s10, p.emission_moneta * 11);
    assert_eq!(s100, p.emission_moneta * 101);
}

// ---------- apply_proposal determinism ----------

#[test]
fn apply_proposal_deterministic() {
    let p = mt_genesis::genesis_params();
    let g1 = build_genesis_state(p);
    let g2 = build_genesis_state(p);

    let mut a1 = g1.account_table;
    let mut n1 = g1.node_table;
    let c1 = g1.candidate_pool;

    let mut a2 = g2.account_table;
    let mut n2 = g2.node_table;
    let c2 = g2.candidate_pool;

    let node_id = derive_node_id(&p.bootstrap_node_pubkey);
    let input = ProposalSettle {
        window_w: 5,
        winner_id: node_id,
        cemented_confirmers: vec![],
    };

    let r1 = apply_proposal(&mut a1, &mut n1, &c1, &input, p);
    let r2 = apply_proposal(&mut a2, &mut n2, &c2, &input, p);
    assert_eq!(r1, r2);
}

#[test]
fn apply_proposal_emission_changes_balance() {
    let p = mt_genesis::genesis_params();
    let g = build_genesis_state(p);
    let mut account_table = g.account_table;
    let mut node_table = g.node_table;
    let candidate_pool = g.candidate_pool;

    let account_id = derive_account_id(GENESIS_SUITE_ID, &p.bootstrap_account_pubkey);
    let node_id = derive_node_id(&p.bootstrap_node_pubkey);
    let balance_before = account_table.get(&account_id).unwrap().balance;

    let input = ProposalSettle {
        window_w: 3,
        winner_id: node_id,
        cemented_confirmers: vec![],
    };
    apply_proposal(
        &mut account_table,
        &mut node_table,
        &candidate_pool,
        &input,
        p,
    );

    let balance_after = account_table.get(&account_id).unwrap().balance;
    assert_eq!(
        balance_after,
        balance_before + p.emission_moneta,
        "Operator получает EMISSION_moneta"
    );
}

// ---------- Static API invariants ----------

#[test]
fn record_sizes_positive() {
    const _: () = assert!(TRANSFER_SIZE > 0);
    const _: () = assert!(CHANGE_KEY_SIZE > 0);
    const _: () = assert!(ANCHOR_SIZE > 0);
    const _: () = assert!(TRANSFER_ACTIVATION_SIZE > 0);
}

#[test]
fn genesis_suite_id_is_one() {
    assert_eq!(GENESIS_SUITE_ID, 1);
}

// ---------- M3-3 closure: checked arithmetic panic on protocol breach ----------

#[test]
#[should_panic(expected = "balance underflow")]
fn apply_transfer_panics_on_unsanitized_underflow() {
    // Если кто-то вызывает apply_transfer без предварительного validate_transfer
    // и balance < amount — должен быть controlled halt, не silent wrap.
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 100); // balance = 100
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    state.insert(sample_account(0xBB, 0));

    let op = sample_transfer([0xAA; 32], [0xBB; 32], 1000); // amount = 1000 > balance
    apply_transfer(&op, &mut state, 5);
}

// ---------- M3-1 closure: window_w u64 unification ----------

#[test]
fn apply_accepts_u64_window() {
    // Compile-time проверка signature — все apply_* принимают u64.
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    state.insert(sample_account(0xBB, 0));

    let op_t = Operation::Transfer(sample_transfer([0xAA; 32], [0xBB; 32], 100));
    let large_window: u64 = 1_000_000_000; // > u32::MAX/4 but < u32::MAX
    apply(&op_t, &mut state, large_window);
}

#[test]
#[should_panic(expected = "encoded arithmetic horizon")]
fn apply_panics_on_window_w_above_u32_max() {
    // window_w > u32::MAX → controlled halt (encoded arithmetic horizon).
    let mut state = AccountTable::new();
    let mut acct = sample_account(0xAA, 1_000_000);
    acct.frontier_hash = [0xBB; 32];
    state.insert(acct);
    state.insert(sample_account(0xBB, 0));

    let op = sample_transfer([0xAA; 32], [0xBB; 32], 100);
    apply_transfer(&op, &mut state, u64::from(u32::MAX) + 1);
}