iota_core/authority/

authority_test_utils.rs

// Copyright (c) 2021, Facebook, Inc. and its affiliates
// Copyright (c) Mysten Labs, Inc.
// Modifications Copyright (c) 2024 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use std::sync::Arc;

use fastcrypto::{hash::MultisetHash, traits::KeyPair};
use iota_config::{genesis::Genesis, node::ExpensiveSafetyCheckConfig};
use iota_sdk_types::{
    Address, ObjectId, ObjectReference, Owner, RandomnessRound, Transaction, TransactionEffects,
    Version, VersionAssignment,
};
use iota_types::{
    crypto::{AccountPrivateKey, AuthorityKeyPair},
    effects::SignedTransactionEffects,
    error::{ExecutionError, IotaError},
    executable_transaction::VerifiedExecutableTransaction,
    messages_consensus::ConsensusTransaction,
    object::Object,
    signature::VerifyParams,
    transaction::{
        CertifiedTransaction, SenderSignedTransactionAPI, TEST_ONLY_GAS_UNIT_FOR_TRANSFER,
        TransactionAPI, TransactionEnvelope, TransactionKey, VerifiedCertificate,
        VerifiedSignedTransaction, VerifiedTransaction,
    },
    utils::to_sender_signed_transaction,
};

use super::{
    authority_per_epoch_store::AuthorityPerEpochStore,
    epoch_start_configuration::EpochStartConfigTrait,
    shared_object_version_manager::{AssignedTxAndVersions, AssignedVersions, Schedulable},
    test_authority_builder::TestAuthorityBuilder,
};
use crate::{
    authority::{AuthorityState, ExecutionEnv},
    checkpoints::CheckpointServiceNoop,
    consensus_handler::SequencedConsensusTransaction,
    execution_scheduler::{
        ExecutionSchedulerAPI, transaction_manager::SchedulableAttestedTransaction,
    },
    global_state_hasher::GlobalStateHasher,
};

pub async fn send_and_confirm_transaction(
    authority: &AuthorityState,
    transaction: TransactionEnvelope,
) -> Result<(CertifiedTransaction, SignedTransactionEffects), IotaError> {
    send_and_confirm_transaction_(
        authority,
        None, // no fullnode_key_pair
        transaction,
        false, // no shared objects
    )
    .await
}
pub async fn send_and_confirm_transaction_(
    authority: &AuthorityState,
    fullnode: Option<&AuthorityState>,
    transaction: TransactionEnvelope,
    with_shared: bool, // transaction includes shared objects
) -> Result<(CertifiedTransaction, SignedTransactionEffects), IotaError> {
    let (txn, effects, _execution_error_opt) = send_and_confirm_transaction_with_execution_error(
        authority,
        fullnode,
        transaction,
        with_shared,
        true,
    )
    .await?;
    Ok((txn, effects))
}

pub async fn certify_transaction(
    authority: &AuthorityState,
    transaction: TransactionEnvelope,
) -> Result<VerifiedCertificate, IotaError> {
    // Make the initial request
    let epoch_store = authority.load_epoch_store_one_call_per_task();
    // TODO: Move this check to a more appropriate place.
    transaction.validity_check(&epoch_store.tx_validity_check_context())?;
    let transaction = epoch_store.verify_transaction(transaction).unwrap();

    let response = authority
        .handle_transaction(&epoch_store, transaction.clone())
        .await?;
    let vote = response.status.into_signed_for_testing();
    // As in `init_certified_transaction`.
    epoch_store.assign_to_a_new_commit_for_testing(&[transaction.key()]);

    // Collect signatures from a quorum of authorities
    let committee = authority.clone_committee_for_testing();
    let certificate = CertifiedTransaction::new(transaction.into_message(), vec![vote], &committee)
        .unwrap()
        .try_into_verified_for_testing(
            &committee,
            &VerifyParams::from_protocol_config(epoch_store.protocol_config()),
        )
        .unwrap();
    Ok(certificate)
}

pub async fn execute_certificate_with_execution_error(
    authority: &AuthorityState,
    fullnode: Option<&AuthorityState>,
    certificate: VerifiedCertificate,
    with_shared: bool, // transaction includes shared objects
    fake_consensus: bool,
) -> Result<
    (
        CertifiedTransaction,
        SignedTransactionEffects,
        Option<ExecutionError>,
    ),
    IotaError,
> {
    // We also check the incremental effects of the transaction on the live object
    // set against GlobalStateHasher for testing and regression detection.
    // We must do this before sending to consensus, otherwise consensus may already
    // lead to transaction execution and state change.
    let state_acc =
        GlobalStateHasher::new_for_tests(authority.get_global_state_hash_store().clone());
    let mut state = state_acc.accumulate_cached_live_object_set_for_testing()?;

    let assigned_versions = if with_shared {
        if fake_consensus {
            send_consensus(authority, &certificate).await
        } else {
            // Just set object locks directly if send_consensus is not requested.
            let assigned_versions = authority
                .epoch_store_for_testing()
                .assign_shared_object_versions_for_tests(
                    authority.get_object_cache_reader().as_ref(),
                    &[VerifiedExecutableTransaction::new_from_certificate(
                        certificate.clone(),
                    )],
                )?;
            assigned_versions
                .into_map()
                .get(&certificate.key())
                .cloned()
                .unwrap()
        }
    } else {
        vec![]
    };

    // Submit the confirmation. *Now* execution actually happens, and it should fail
    // when we try to look up our dummy module. we unfortunately don't get a
    // very descriptive error message, but we can at least see that something went
    // wrong inside the VM
    let (result, execution_error_opt) = authority.try_execute_for_test(
        &certificate,
        ExecutionEnv::new().with_assigned_versions(assigned_versions.clone()),
    )?;
    let state_after = state_acc.accumulate_cached_live_object_set_for_testing()?;
    let effects_acc = state_acc.accumulate_effects(&[result.inner().data().clone()]);
    state.union(&effects_acc);

    assert_eq!(state_after.digest(), state.digest());

    if let Some(fullnode) = fullnode {
        fullnode.try_execute_for_test(
            &certificate,
            ExecutionEnv::new().with_assigned_versions(assigned_versions),
        )?;
    }
    Ok((
        certificate.into_inner(),
        result.into_inner(),
        execution_error_opt,
    ))
}

pub async fn send_and_confirm_transaction_with_execution_error(
    authority: &AuthorityState,
    fullnode: Option<&AuthorityState>,
    transaction: TransactionEnvelope,
    with_shared: bool,    // transaction includes shared objects
    fake_consensus: bool, // runs consensus handler if true
) -> Result<
    (
        CertifiedTransaction,
        SignedTransactionEffects,
        Option<ExecutionError>,
    ),
    IotaError,
> {
    let certificate = certify_transaction(authority, transaction).await?;
    execute_certificate_with_execution_error(
        authority,
        fullnode,
        certificate,
        with_shared,
        fake_consensus,
    )
    .await
}

pub async fn init_state_validator_with_fullnode() -> (Arc<AuthorityState>, Arc<AuthorityState>) {
    use iota_types::crypto::get_authority_key_pair;

    let validator = TestAuthorityBuilder::new().build().await;
    let fullnode_key_pair = get_authority_key_pair().1;
    let fullnode = TestAuthorityBuilder::new()
        .with_keypair(&fullnode_key_pair)
        .build()
        .await;
    (validator, fullnode)
}

pub async fn init_state_with_committee(
    genesis: &Genesis,
    authority_key: &AuthorityKeyPair,
) -> Arc<AuthorityState> {
    TestAuthorityBuilder::new()
        .with_genesis_and_keypair(genesis, authority_key)
        .build()
        .await
}

pub async fn init_state_with_ids<I: IntoIterator<Item = (Address, ObjectId)>>(
    objects: I,
) -> Arc<AuthorityState> {
    let state = TestAuthorityBuilder::new().build().await;
    for (address, object_id) in objects {
        let obj = Object::with_id_owner_for_testing(object_id, address);
        // TODO: Make this part of genesis initialization instead of explicit insert.
        state.insert_genesis_object(obj);
    }
    state
}

pub async fn init_state_with_ids_and_versions<
    I: IntoIterator<Item = (Address, ObjectId, Version)>,
>(
    objects: I,
) -> Arc<AuthorityState> {
    let state = TestAuthorityBuilder::new().build().await;
    for (address, object_id, version) in objects {
        let obj =
            Object::with_id_owner_version_for_testing(object_id, version, Owner::Address(address));
        state.insert_genesis_object(obj);
    }
    state
}

pub async fn init_state_with_objects<I: IntoIterator<Item = Object>>(
    objects: I,
) -> Arc<AuthorityState> {
    let dir = tempfile::TempDir::new().unwrap();
    let network_config =
        iota_swarm_config::network_config_builder::ConfigBuilder::new(&dir).build();
    let genesis = network_config.genesis;
    let keypair = network_config.validator_configs[0]
        .authority_key_pair()
        .copy();
    init_state_with_objects_and_committee(objects, &genesis, &keypair).await
}

pub async fn init_state_with_objects_and_committee<I: IntoIterator<Item = Object>>(
    objects: I,
    genesis: &Genesis,
    authority_key: &AuthorityKeyPair,
) -> Arc<AuthorityState> {
    let state = init_state_with_committee(genesis, authority_key).await;
    for o in objects {
        state.insert_genesis_object(o);
    }
    state
}

pub async fn init_state_with_object_id(address: Address, object: ObjectId) -> Arc<AuthorityState> {
    init_state_with_ids(std::iter::once((address, object))).await
}

pub async fn init_state_with_ids_and_expensive_checks<
    I: IntoIterator<Item = (Address, ObjectId)>,
>(
    objects: I,
    config: ExpensiveSafetyCheckConfig,
) -> Arc<AuthorityState> {
    let state = TestAuthorityBuilder::new()
        .with_expensive_safety_checks(config)
        .build()
        .await;
    for (address, object_id) in objects {
        let obj = Object::with_id_owner_for_testing(object_id, address);
        // TODO: Make this part of genesis initialization instead of explicit insert.
        state.insert_genesis_object(obj);
    }
    state
}

pub fn init_transfer_transaction(
    authority_state: &AuthorityState,
    sender: Address,
    secret: &AccountPrivateKey,
    recipient: Address,
    object_ref: ObjectReference,
    gas_object_ref: ObjectReference,
    gas_budget: u64,
    gas_price: u64,
) -> VerifiedTransaction {
    let tx = Transaction::new_transfer(
        recipient,
        object_ref,
        sender,
        gas_object_ref,
        gas_budget,
        gas_price,
    );
    let tx = to_sender_signed_transaction(tx, secret);
    authority_state
        .epoch_store_for_testing()
        .verify_transaction(tx)
        .unwrap()
}

pub fn init_certified_transfer_transaction(
    sender: Address,
    secret: &AccountPrivateKey,
    recipient: Address,
    object_ref: ObjectReference,
    gas_object_ref: ObjectReference,
    authority_state: &AuthorityState,
) -> VerifiedCertificate {
    let rgp = authority_state.reference_gas_price_for_testing().unwrap();
    let transfer_transaction = init_transfer_transaction(
        authority_state,
        sender,
        secret,
        recipient,
        object_ref,
        gas_object_ref,
        rgp * TEST_ONLY_GAS_UNIT_FOR_TRANSFER,
        rgp,
    );
    init_certified_transaction(transfer_transaction.into(), authority_state)
}

/// With the P-COOL flow, the transaction is also assigned to a new commit,
/// as the consensus handler assigns every transaction it sequences before
/// it can execute.
pub fn init_certified_transaction(
    transaction: TransactionEnvelope,
    authority_state: &AuthorityState,
) -> VerifiedCertificate {
    let epoch_store = authority_state.epoch_store_for_testing();
    let transaction = epoch_store.verify_transaction(transaction).unwrap();
    epoch_store.assign_to_a_new_commit_for_testing(&[transaction.key()]);

    let vote = VerifiedSignedTransaction::new(
        0,
        transaction.clone(),
        authority_state.name,
        &*authority_state.secret,
    );
    CertifiedTransaction::new(
        transaction.into_message(),
        vec![vote.auth_sig().clone()],
        epoch_store.committee(),
    )
    .unwrap()
    .try_into_verified_for_testing(
        epoch_store.committee(),
        &VerifyParams::from_protocol_config(epoch_store.protocol_config()),
    )
    .unwrap()
}

pub async fn certify_shared_obj_transaction_no_execution(
    authority: &AuthorityState,
    transaction: TransactionEnvelope,
) -> Result<(VerifiedCertificate, AssignedVersions), IotaError> {
    let epoch_store = authority.load_epoch_store_one_call_per_task();
    let transaction = epoch_store.verify_transaction(transaction).unwrap();
    let response = authority
        .handle_transaction(&epoch_store, transaction.clone())
        .await?;
    let vote = response.status.into_signed_for_testing();

    // Collect signatures from a quorum of authorities
    let committee = authority.clone_committee_for_testing();
    let certificate =
        CertifiedTransaction::new(transaction.into_message(), vec![vote.clone()], &committee)
            .unwrap()
            .try_into_verified_for_testing(
                &committee,
                &VerifyParams::from_protocol_config(epoch_store.protocol_config()),
            )
            .unwrap();

    let assigned_versions = send_consensus_no_execution(authority, &certificate).await;

    Ok((certificate, assigned_versions))
}

pub async fn enqueue_all_and_execute_all(
    authority: &AuthorityState,
    certificates: Vec<(VerifiedCertificate, ExecutionEnv)>,
) -> Result<Vec<TransactionEffects>, IotaError> {
    authority.execution_scheduler().enqueue(
        certificates
            .iter()
            .map(|(cert, env)| {
                (
                    VerifiedExecutableTransaction::new_from_certificate(cert.clone()).into(),
                    env.clone(),
                )
            })
            .collect(),
        &authority.epoch_store_for_testing(),
    );
    let mut output = Vec::new();
    for (cert, _) in certificates {
        let effects = authority.notify_read_effects("", &cert).await?;
        output.push(effects);
    }
    Ok(output)
}

pub async fn execute_sequenced_certificate_to_effects(
    authority: &AuthorityState,
    certificate: VerifiedCertificate,
    assigned_versions: AssignedVersions,
) -> Result<(TransactionEffects, Option<ExecutionError>), IotaError> {
    let env = ExecutionEnv::new().with_assigned_versions(assigned_versions);
    authority
        .epoch_store_for_testing()
        .assign_to_a_new_commit_for_testing(&[certificate.key()]);
    authority.execution_scheduler().enqueue(
        vec![(
            VerifiedExecutableTransaction::new_from_certificate(certificate.clone()).into(),
            env.clone(),
        )],
        &authority.epoch_store_for_testing(),
    );

    let (result, execution_error_opt) = authority.try_execute_for_test(&certificate, env)?;
    let effects = result.inner().data().clone();
    Ok((effects, execution_error_opt))
}

pub async fn send_consensus(
    authority: &AuthorityState,
    cert: &VerifiedCertificate,
) -> AssignedVersions {
    let transaction = SequencedConsensusTransaction::new_test(
        ConsensusTransaction::new_certificate_message(&authority.name, cert.clone().into_inner()),
    );

    let (_, assigned_versions) = authority
        .epoch_store_for_testing()
        .process_consensus_transactions_for_tests(
            vec![transaction],
            &Arc::new(CheckpointServiceNoop {}),
            authority.get_object_cache_reader().as_ref(),
            &authority.metrics,
            true,
            authority,
        )
        .await
        .unwrap();

    let assigned_versions = assigned_versions
        .into_map()
        .remove(&cert.key())
        .unwrap_or_default();

    let certs = vec![(
        VerifiedExecutableTransaction::new_from_certificate(cert.clone()),
        ExecutionEnv::new().with_assigned_versions(assigned_versions.clone()),
    )];

    let epoch_store = authority.epoch_store_for_testing();
    epoch_store.assign_to_a_new_commit_for_testing(&[cert.key()]);
    authority
        .execution_scheduler()
        .enqueue_transactions(certs, &epoch_store);

    assigned_versions
}

/// For a certificate with shared inputs: the commit must assign it versions.
pub async fn send_consensus_no_execution(
    authority: &AuthorityState,
    cert: &VerifiedCertificate,
) -> AssignedVersions {
    let transaction = SequencedConsensusTransaction::new_test(
        ConsensusTransaction::new_certificate_message(&authority.name, cert.clone().into_inner()),
    );

    // Call process_consensus_transaction() instead of
    // handle_consensus_transaction(), to avoid actually executing cert.
    // This allows testing cert execution independently.
    let (_, assigned_versions) = authority
        .epoch_store_for_testing()
        .process_consensus_transactions_for_tests(
            vec![transaction],
            &Arc::new(CheckpointServiceNoop {}),
            authority.get_object_cache_reader().as_ref(),
            &authority.metrics,
            true,
            authority,
        )
        .await
        .unwrap();
    assert_eq!(assigned_versions.0.len(), 1);
    assigned_versions
        .into_map()
        .remove(&cert.key())
        .expect("the commit must have assigned versions for this certificate")
}

pub async fn send_batch_consensus_no_execution(
    authority: &AuthorityState,
    certificates: &[VerifiedCertificate],
    skip_consensus_commit_prologue_in_test: bool,
) -> (Vec<Schedulable>, AssignedTxAndVersions) {
    let transactions = certificates
        .iter()
        .map(|cert| {
            SequencedConsensusTransaction::new_test(ConsensusTransaction::new_certificate_message(
                &authority.name,
                cert.clone().into_inner(),
            ))
        })
        .collect();

    // Call process_consensus_transaction() instead of
    // handle_consensus_transaction(), to avoid actually executing cert.
    // This allows testing cert execution independently.
    let (scheduled, assigned_versions) = authority
        .epoch_store_for_testing()
        .process_consensus_transactions_for_tests(
            transactions,
            &Arc::new(CheckpointServiceNoop {}),
            authority.get_object_cache_reader().as_ref(),
            &authority.metrics,
            skip_consensus_commit_prologue_in_test,
            authority,
        )
        .await
        .unwrap();
    (drop_attestations(scheduled), assigned_versions)
}

/// The scheduled transactions without their attestations, for tests that
/// hand them to the scheduler's plain interface.
pub fn drop_attestations(scheduled: Vec<SchedulableAttestedTransaction>) -> Vec<Schedulable> {
    scheduled
        .into_iter()
        .map(|scheduled| match scheduled {
            Schedulable::Transaction(attested) => Schedulable::Transaction(attested.into_parts().0),
            Schedulable::RandomnessStateUpdate(epoch, round) => {
                Schedulable::RandomnessStateUpdate(epoch, round)
            }
        })
        .collect()
}

/// Builds the randomness state update for `round`, persists it and records its
/// key, which is what `RandomnessRoundReceiver` does before it notifies.
pub fn resolve_randomness_round(
    state: &AuthorityState,
    epoch_store: &AuthorityPerEpochStore,
    round: u64,
) -> VerifiedExecutableTransaction {
    let transaction = make_randomness_state_update(epoch_store, round);
    state.get_cache_commit().persist_transaction(&transaction);
    epoch_store
        .insert_tx_key(
            TransactionKey::RandomnessRound(epoch_store.epoch(), RandomnessRound::new(round)),
            *transaction.digest(),
        )
        .unwrap();
    transaction
}

pub fn randomness_assigned_versions(
    epoch_store: &AuthorityPerEpochStore,
) -> Vec<VersionAssignment> {
    vec![VersionAssignment::new(
        ObjectId::RANDOMNESS_STATE,
        epoch_store
            .epoch_start_config()
            .randomness_obj_initial_shared_version(),
    )]
}

/// A randomness state update transaction for `round`, as
/// `RandomnessRoundReceiver` would build it.
pub fn make_randomness_state_update(
    epoch_store: &AuthorityPerEpochStore,
    round: u64,
) -> VerifiedExecutableTransaction {
    VerifiedExecutableTransaction::new_system(
        VerifiedTransaction::new_randomness_state_update(
            epoch_store.epoch(),
            RandomnessRound::new(round),
            vec![round as u8],
            epoch_store
                .epoch_start_config()
                .randomness_obj_initial_shared_version(),
        ),
        epoch_store.epoch(),
    )
}