iota_transactional_test_runner/

lib.rs

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

//! This module contains the transactional test runner instantiation for the
//! IOTA adapter

pub mod args;
pub mod offchain_state;
pub mod programmable_transaction_test_parser;
mod simulator_persisted_store;
pub mod test_adapter;

use std::{path::Path, sync::Arc};

use iota_core::authority::{
    AuthorityState, authority_per_epoch_store::TxLockGuard,
    authority_test_utils::send_and_confirm_transaction_with_execution_error,
    shared_object_version_manager::AssignedVersions,
};
use iota_json_rpc::authority_state::StateRead;
use iota_sdk_types::{
    Address, CheckpointContents, CheckpointContentsDigest, CheckpointDigest, Event, ObjectId,
    Transaction, TransactionDigest, TransactionEffects, TransactionEvents,
};
use iota_storage::key_value_store::TransactionKeyValueStore;
use iota_types::{
    base_types::VersionNumber,
    committee::EpochId,
    error::{ExecutionError, IotaError, IotaResult},
    executable_transaction::{ExecutableTransaction, VerifiedExecutableTransaction},
    iota_system_state::{
        IotaSystemStateTrait, epoch_start_iota_system_state::EpochStartSystemStateTrait,
        iota_system_state_summary::IotaSystemStateSummary,
    },
    messages_checkpoint::VerifiedCheckpoint,
    object::Object,
    storage::{ObjectStore, ReadStore},
    transaction::{InputObjects, SenderSignedTransactionAPI, TransactionEnvelope},
    transaction_executor::{SimulateTransactionResult, VmChecks},
};
pub use move_transactional_test_runner::framework::{
    create_adapter, run_tasks_with_adapter, run_test_impl,
};
use rand::rngs::StdRng;
use simulacrum::{Simulacrum, SimulatorStore};
use simulator_persisted_store::PersistedStore;
use test_adapter::{IotaTestAdapter, PRE_COMPILED};

#[cfg_attr(not(msim), tokio::main)]
#[cfg_attr(msim, msim::main)]
pub async fn run_test(path: &Path) -> Result<(), Box<dyn std::error::Error>> {
    let (_guard, _filter_handle) = telemetry_subscribers::TelemetryConfig::new()
        .with_env()
        .init();
    run_test_impl::<IotaTestAdapter>(path, Some(std::sync::Arc::new(PRE_COMPILED.clone()))).await?;
    Ok(())
}

pub struct ValidatorWithFullnode {
    pub validator: Arc<AuthorityState>,
    pub fullnode: Arc<AuthorityState>,
    pub kv_store: Arc<TransactionKeyValueStore>,
}

/// TODO: better name?
#[async_trait::async_trait]
pub trait TransactionalAdapter: Send + Sync + ReadStore {
    async fn execute_txn(
        &mut self,
        transaction: TransactionEnvelope,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)>;

    async fn read_input_objects(
        &self,
        transaction: TransactionEnvelope,
        assigned_versions: AssignedVersions,
    ) -> IotaResult<InputObjects>;

    fn prepare_txn(
        &self,
        transaction: TransactionEnvelope,
        input_objects: InputObjects,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)>;

    async fn create_checkpoint(&mut self) -> anyhow::Result<VerifiedCheckpoint>;

    async fn advance_clock(
        &mut self,
        duration: std::time::Duration,
    ) -> anyhow::Result<TransactionEffects>;

    /// Returns the effects of the end-of-epoch transaction when the executor
    /// exposes them (the simulator does, the validator setup does not).
    async fn advance_epoch(
        &mut self,
        create_deny_rules_object: bool,
    ) -> anyhow::Result<Option<TransactionEffects>>;

    async fn request_gas(
        &mut self,
        address: Address,
        amount: u64,
    ) -> anyhow::Result<TransactionEffects>;

    async fn simulate_transaction(
        &self,
        transaction: Transaction,
        checks: VmChecks,
    ) -> IotaResult<SimulateTransactionResult>;

    async fn query_tx_events_asc(
        &self,
        tx_digest: &TransactionDigest,
        limit: usize,
    ) -> IotaResult<Vec<Event>>;

    async fn get_active_validator_addresses(&self) -> IotaResult<Vec<Address>>;
}

#[async_trait::async_trait]
impl TransactionalAdapter for ValidatorWithFullnode {
    async fn execute_txn(
        &mut self,
        transaction: TransactionEnvelope,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)> {
        let with_shared = transaction.contains_shared_object();
        let (_, effects, execution_error) = send_and_confirm_transaction_with_execution_error(
            &self.validator,
            Some(&self.fullnode),
            transaction,
            with_shared,
            false,
        )
        .await?;
        Ok((effects.into_data(), execution_error))
    }

    async fn read_input_objects(
        &self,
        transaction: TransactionEnvelope,
        assigned_versions: AssignedVersions,
    ) -> IotaResult<InputObjects> {
        let tx = VerifiedExecutableTransaction::new_unchecked(
            ExecutableTransaction::new_from_data_and_sig(
                transaction.data().clone(),
                iota_types::executable_transaction::CertificateProof::Checkpoint(0, 0),
            ),
        );

        let epoch_store = self.validator.load_epoch_store_one_call_per_task().clone();
        self.validator
            .read_objects_for_execution(
                &TxLockGuard::guard_for_tests(),
                &tx,
                assigned_versions,
                &epoch_store,
            )
            .map(|(tx_input_objects, _)| tx_input_objects)
    }

    fn prepare_txn(
        &self,
        transaction: TransactionEnvelope,
        input_objects: InputObjects,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)> {
        let tx = VerifiedExecutableTransaction::new_unchecked(
            ExecutableTransaction::new_from_data_and_sig(
                transaction.data().clone(),
                iota_types::executable_transaction::CertificateProof::Checkpoint(0, 0),
            ),
        );

        let epoch_store = self.validator.load_epoch_store_one_call_per_task().clone();
        let (_, effects, error) =
            self.validator
                .prepare_transaction_for_benchmark(&tx, input_objects, &epoch_store)?;
        Ok((effects, error))
    }

    async fn simulate_transaction(
        &self,
        transaction: Transaction,
        checks: VmChecks,
    ) -> IotaResult<SimulateTransactionResult> {
        self.fullnode.simulate_transaction(transaction, checks)
    }

    async fn query_tx_events_asc(
        &self,
        tx_digest: &TransactionDigest,
        limit: usize,
    ) -> IotaResult<Vec<Event>> {
        // Read from the store rather than the JSON-RPC index, which indexes a
        // transaction only once its checkpoint executes, and these tests
        // execute no checkpoints.
        let events = self
            .try_get_events(tx_digest)?
            .map_or_else(Vec::new, |e| e.0);
        Ok(events.into_iter().take(limit).collect())
    }

    async fn create_checkpoint(&mut self) -> anyhow::Result<VerifiedCheckpoint> {
        unimplemented!("create_checkpoint not supported")
    }

    async fn advance_clock(
        &mut self,
        _duration: std::time::Duration,
    ) -> anyhow::Result<TransactionEffects> {
        unimplemented!("advance_clock not supported")
    }

    async fn advance_epoch(
        &mut self,
        create_deny_rules_object: bool,
    ) -> anyhow::Result<Option<TransactionEffects>> {
        anyhow::ensure!(
            !create_deny_rules_object,
            "--create-deny-rules-object is only supported in simulator mode"
        );
        self.validator.reconfigure_for_testing().await;
        self.fullnode.reconfigure_for_testing().await;
        Ok(None)
    }

    async fn request_gas(
        &mut self,
        _address: Address,
        _amount: u64,
    ) -> anyhow::Result<TransactionEffects> {
        unimplemented!("request_gas not supported")
    }

    async fn get_active_validator_addresses(&self) -> IotaResult<Vec<Address>> {
        let system_state_summary = self
            .fullnode
            .get_system_state()
            .map_err(|e| {
                IotaError::IotaSystemStateRead(format!(
                    "Failed to get system state from fullnode: {e}"
                ))
            })?
            .into_iota_system_state_summary();
        let active_validators = match system_state_summary {
            IotaSystemStateSummary::V1(inner) => inner.active_validators,
            IotaSystemStateSummary::V2(inner) => inner.active_validators,
            _ => unimplemented!(
                "a new IotaSystemStateSummary enum variant was added and needs to be handled"
            ),
        };

        Ok(active_validators
            .iter()
            .map(|x| x.iota_address)
            .collect::<Vec<_>>())
    }
}

impl ReadStore for ValidatorWithFullnode {
    fn try_get_committee(
        &self,
        _epoch: EpochId,
    ) -> iota_types::storage::error::Result<Option<Arc<iota_types::committee::Committee>>> {
        todo!()
    }

    fn try_get_latest_epoch_id(&self) -> iota_types::storage::error::Result<EpochId> {
        Ok(self.validator.epoch_store_for_testing().epoch())
    }

    fn try_get_latest_checkpoint(&self) -> iota_types::storage::error::Result<VerifiedCheckpoint> {
        let sequence_number = self
            .validator
            .get_latest_checkpoint_sequence_number()
            .unwrap();
        self.try_get_checkpoint_by_sequence_number(sequence_number)
            .map(|c| c.unwrap())
    }

    fn try_get_highest_verified_checkpoint(
        &self,
    ) -> iota_types::storage::error::Result<VerifiedCheckpoint> {
        todo!()
    }

    fn try_get_highest_synced_checkpoint(
        &self,
    ) -> iota_types::storage::error::Result<VerifiedCheckpoint> {
        todo!()
    }

    fn try_get_lowest_available_checkpoint(
        &self,
    ) -> iota_types::storage::error::Result<iota_types::messages_checkpoint::CheckpointSequenceNumber>
    {
        todo!()
    }

    fn try_get_checkpoint_by_digest(
        &self,
        _digest: &CheckpointDigest,
    ) -> iota_types::storage::error::Result<Option<VerifiedCheckpoint>> {
        todo!()
    }

    fn try_get_checkpoint_by_sequence_number(
        &self,
        sequence_number: iota_types::messages_checkpoint::CheckpointSequenceNumber,
    ) -> iota_types::storage::error::Result<Option<VerifiedCheckpoint>> {
        self.validator
            .get_checkpoint_store()
            .get_checkpoint_by_sequence_number(sequence_number)
            .map_err(iota_types::storage::error::Error::custom)
    }

    fn try_get_checkpoint_contents_by_digest(
        &self,
        digest: &CheckpointContentsDigest,
    ) -> iota_types::storage::error::Result<Option<CheckpointContents>> {
        self.validator
            .get_checkpoint_store()
            .get_checkpoint_contents(digest)
            .map_err(iota_types::storage::error::Error::custom)
    }

    fn try_get_checkpoint_contents_by_sequence_number(
        &self,
        _sequence_number: iota_types::messages_checkpoint::CheckpointSequenceNumber,
    ) -> iota_types::storage::error::Result<Option<CheckpointContents>> {
        todo!()
    }

    fn try_get_transaction(
        &self,
        tx_digest: &TransactionDigest,
    ) -> iota_types::storage::error::Result<Option<Arc<iota_types::transaction::VerifiedTransaction>>>
    {
        self.validator
            .get_transaction_cache_reader()
            .try_get_transaction_block(tx_digest)
            .map_err(iota_types::storage::error::Error::custom)
    }

    fn try_get_transaction_effects(
        &self,
        tx_digest: &TransactionDigest,
    ) -> iota_types::storage::error::Result<Option<TransactionEffects>> {
        self.validator
            .get_transaction_cache_reader()
            .try_get_executed_effects(tx_digest)
            .map_err(iota_types::storage::error::Error::custom)
    }

    fn try_get_events(
        &self,
        digest: &TransactionDigest,
    ) -> iota_types::storage::error::Result<Option<TransactionEvents>> {
        self.validator
            .get_transaction_cache_reader()
            .try_get_events(digest)
            .map_err(iota_types::storage::error::Error::custom)
    }

    fn try_get_full_checkpoint_contents_by_sequence_number(
        &self,
        _sequence_number: iota_types::messages_checkpoint::CheckpointSequenceNumber,
    ) -> iota_types::storage::error::Result<
        Option<iota_types::messages_checkpoint::FullCheckpointContents>,
    > {
        todo!()
    }

    fn try_get_full_checkpoint_contents(
        &self,
        _digest: &CheckpointContentsDigest,
    ) -> iota_types::storage::error::Result<
        Option<iota_types::messages_checkpoint::FullCheckpointContents>,
    > {
        todo!()
    }
}

impl ObjectStore for ValidatorWithFullnode {
    fn try_get_object(
        &self,
        object_id: &ObjectId,
    ) -> Result<Option<Object>, iota_types::storage::error::Error> {
        self.validator.get_object_store().try_get_object(object_id)
    }

    fn try_get_object_by_key(
        &self,
        object_id: &ObjectId,
        version: VersionNumber,
    ) -> Result<Option<Object>, iota_types::storage::error::Error> {
        self.validator
            .get_object_store()
            .try_get_object_by_key(object_id, version)
    }
}

#[async_trait::async_trait]
impl TransactionalAdapter for Simulacrum<StdRng, PersistedStore> {
    async fn execute_txn(
        &mut self,
        transaction: TransactionEnvelope,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)> {
        Ok(self.execute_transaction(transaction)?)
    }

    async fn read_input_objects(
        &self,
        _transaction: TransactionEnvelope,
        _assigned_versions: AssignedVersions,
    ) -> IotaResult<InputObjects> {
        unimplemented!("read_input_objects not supported in simulator mode")
    }

    fn prepare_txn(
        &self,
        _transaction: TransactionEnvelope,
        _input_objects: InputObjects,
    ) -> anyhow::Result<(TransactionEffects, Option<ExecutionError>)> {
        unimplemented!("prepare_txn not supported in simulator mode")
    }

    async fn simulate_transaction(
        &self,
        transaction: Transaction,
        checks: VmChecks,
    ) -> IotaResult<SimulateTransactionResult> {
        Simulacrum::simulate_transaction(self, transaction, checks)
    }

    async fn query_tx_events_asc(
        &self,
        tx_digest: &TransactionDigest,
        _limit: usize,
    ) -> IotaResult<Vec<Event>> {
        match self.try_get_events(tx_digest)? {
            Some(events) => Ok(events.0),
            None => Ok(Vec::new()),
        }
    }

    async fn create_checkpoint(&mut self) -> anyhow::Result<VerifiedCheckpoint> {
        Ok(Simulacrum::create_checkpoint(self))
    }

    async fn advance_clock(
        &mut self,
        duration: std::time::Duration,
    ) -> anyhow::Result<TransactionEffects> {
        Ok(Simulacrum::advance_clock(self, duration))
    }

    async fn advance_epoch(
        &mut self,
        create_deny_rules_object: bool,
    ) -> anyhow::Result<Option<TransactionEffects>> {
        Ok(Some(Simulacrum::advance_epoch(
            self,
            create_deny_rules_object,
        )))
    }

    async fn request_gas(
        &mut self,
        address: Address,
        amount: u64,
    ) -> anyhow::Result<TransactionEffects> {
        Simulacrum::request_gas(self, address, amount)
    }

    async fn get_active_validator_addresses(&self) -> IotaResult<Vec<Address>> {
        // TODO: this is a hack to get the validator addresses. Currently using start
        // state       but we should have a better way to get this information
        // after reconfig
        Ok(self.epoch_start_state().get_validator_addresses())
    }
}