Input commitments tests in chainstate

Author: ImplOfAnImpl

chainstate/test-framework/src/framework.rs

@@ -36,10 +36,10 @@ use common::{
 };
 use crypto::{key::PrivateKey, vrf::VRFPrivateKey};
 use orders_accounting::OrdersAccountingDB;
-use pos_accounting::PoSAccountingDB;
+use pos_accounting::{PoSAccountingDB, PoSAccountingData};
 use randomness::{CryptoRng, Rng};
 use utils::atomics::SeqCstAtomicU64;
-use utxo::{Utxo, UtxosDB};
+use utxo::{Utxo, UtxosDB, UtxosStorageRead};
 
 use crate::{
     framework_builder::TestFrameworkBuilderValue,
@@ -627,6 +627,45 @@ impl TestFramework {
     pub fn utxo(&self, outpoint: &UtxoOutPoint) -> Utxo {
         self.chainstate.utxo(&outpoint).unwrap().unwrap()
     }
+
+    pub fn pos_accounting_data_at_tip(&self) -> PoSAccountingData {
+        self.storage.transaction_ro().unwrap().read_pos_accounting_data_tip().unwrap()
+    }
+
+    pub fn find_kernel_outpoint_for_pool(&self, pool_id: &PoolId) -> Option<UtxoOutPoint> {
+        let utxos = self.storage.transaction_ro().unwrap().read_utxo_set().unwrap();
+
+        let mut outpoints_iter =
+            utxos.into_iter().filter_map(|(outpoint, utxo)| match utxo.output() {
+                TxOutput::ProduceBlockFromStake(_, used_pool_id)
+                | TxOutput::CreateStakePool(used_pool_id, _) => {
+                    (used_pool_id == pool_id).then_some(outpoint)
+                }
+
+                TxOutput::Transfer(_, _)
+                | TxOutput::LockThenTransfer(_, _, _)
+                | TxOutput::Burn(_)
+                | TxOutput::CreateDelegationId(_, _)
+                | TxOutput::DelegateStaking(_, _)
+                | TxOutput::IssueFungibleToken(_)
+                | TxOutput::IssueNft(_, _, _)
+                | TxOutput::DataDeposit(_)
+                | TxOutput::Htlc(_, _)
+                | TxOutput::CreateOrder(_) => None,
+            });
+
+        let result = outpoints_iter.next();
+        assert!(outpoints_iter.next().is_none());
+
+        result
+    }
+
+    // FIXME unify with `utxo` above
+    pub fn coin_amount_from_outpoint(&self, outpoint: &UtxoOutPoint) -> Amount {
+        let storage_tx = self.storage.transaction_ro().unwrap();
+        let utxo = storage_tx.get_utxo(outpoint).unwrap().unwrap();
+        get_output_value(utxo.output()).unwrap().coin_amount().unwrap()
+    }
 }
 
 #[rstest]

chainstate/test-framework/src/lib.rs

@@ -38,9 +38,9 @@ pub type TestChainstate = Box<dyn chainstate::chainstate_interface::ChainstateIn
 pub use {
     crate::utils::{
         anyonecanspend_address, create_chain_config_with_default_staking_pool,
-        create_chain_config_with_staking_pool, create_custom_genesis_with_stake_pool,
-        create_stake_pool_data_with_all_reward_to_staker, empty_witness, get_output_value,
-        output_value_amount, pos_mine, produce_kernel_signature,
+        create_chain_config_with_staking_pool, create_chain_config_with_staking_pool_impl,
+        create_custom_genesis_with_stake_pool, create_stake_pool_data_with_all_reward_to_staker,
+        empty_witness, get_output_value, output_value_amount, pos_mine, produce_kernel_signature,
     },
     block_builder::BlockBuilder,
     framework::TestFramework,

chainstate/test-framework/src/utils.rs

@@ -215,11 +215,28 @@ pub fn create_chain_config_with_staking_pool(
     mint_amount: Amount,
     pool_id: PoolId,
     pool_data: StakePoolData,
+) -> ConfigBuilder {
+    create_chain_config_with_staking_pool_impl(
+        rng,
+        mint_amount,
+        pool_id,
+        pool_data,
+        BlockHeight::new(1),
+    )
+}
+
+// FIXME name
+pub fn create_chain_config_with_staking_pool_impl(
+    rng: &mut impl Rng,
+    mint_amount: Amount,
+    pool_id: PoolId,
+    pool_data: StakePoolData,
+    switch_to_pos_height: BlockHeight,
 ) -> ConfigBuilder {
     let upgrades = vec![
         (BlockHeight::new(0), ConsensusUpgrade::IgnoreConsensus),
         (
-            BlockHeight::new(1),
+            switch_to_pos_height,
             ConsensusUpgrade::PoS {
                 initial_difficulty: Some(Uint256::MAX.into()),
                 config: PoSChainConfigBuilder::new_for_unit_test().build(),

chainstate/test-suite/src/tests/helpers/mod.rs

@@ -23,14 +23,16 @@ use common::{
         output_value::OutputValue,
         signature::inputsig::InputWitness,
         timelock::OutputTimeLock,
-        tokens::{TokenId, TokenIssuance},
-        AccountCommand, AccountNonce, AccountType, Block, Destination, GenBlock, Transaction,
-        TxInput, TxOutput, UtxoOutPoint,
+        tokens::{IsTokenFreezable, TokenId, TokenIssuance, TokenIssuanceV1, TokenTotalSupply},
+        AccountCommand, AccountNonce, AccountType, Block, Destination, GenBlock, OrderId,
+        OrdersVersion, Transaction, TxInput, TxOutput, UtxoOutPoint,
     },
     primitives::{Amount, BlockDistance, BlockHeight, Id, Idable},
 };
 use crypto::key::{KeyKind, PrivateKey};
+use orders_accounting::OrdersAccountingDB;
 use randomness::{CryptoRng, Rng};
+use test_utils::random_ascii_alphanumeric_string;
 
 pub mod block_creation_helpers;
 pub mod block_index_handle_impl;
@@ -185,3 +187,73 @@ pub fn mint_tokens_in_block(
 
     (block_id, tx_id)
 }
+
+// Note: this function will create 2 blocks
+pub fn issue_and_mint_random_token_from_best_block(
+    rng: &mut (impl Rng + CryptoRng),
+    tf: &mut TestFramework,
+    utxo_to_pay_fee: UtxoOutPoint,
+    amount_to_mint: Amount,
+    total_supply: TokenTotalSupply,
+    is_freezable: IsTokenFreezable,
+) -> (
+    TokenId,
+    /*tokens*/ UtxoOutPoint,
+    /*coins change*/ UtxoOutPoint,
+) {
+    let best_block_id = tf.best_block_id();
+    let issuance = {
+        let max_ticker_len = tf.chain_config().token_max_ticker_len();
+        let max_dec_count = tf.chain_config().token_max_dec_count();
+        let max_uri_len = tf.chain_config().token_max_uri_len();
+
+        let issuance = TokenIssuanceV1 {
+            token_ticker: random_ascii_alphanumeric_string(rng, 1..max_ticker_len)
+                .as_bytes()
+                .to_vec(),
+            number_of_decimals: rng.gen_range(1..max_dec_count),
+            metadata_uri: random_ascii_alphanumeric_string(rng, 1..max_uri_len).as_bytes().to_vec(),
+            total_supply,
+            is_freezable,
+            authority: Destination::AnyoneCanSpend,
+        };
+        TokenIssuance::V1(issuance)
+    };
+
+    let (token_id, _, utxo_with_change) =
+        issue_token_from_block(rng, tf, best_block_id, utxo_to_pay_fee, issuance);
+
+    let best_block_id = tf.best_block_id();
+    let (_, mint_tx_id) = mint_tokens_in_block(
+        rng,
+        tf,
+        best_block_id,
+        utxo_with_change,
+        token_id,
+        amount_to_mint,
+        true,
+    );
+
+    (
+        token_id,
+        UtxoOutPoint::new(mint_tx_id.into(), 0),
+        UtxoOutPoint::new(mint_tx_id.into(), 1),
+    )
+}
+
+pub fn calculate_fill_order(
+    tf: &TestFramework,
+    order_id: &OrderId,
+    fill_amount_in_ask_currency: Amount,
+    orders_version: OrdersVersion,
+) -> Amount {
+    let db_tx = tf.storage.transaction_ro().unwrap();
+    let orders_db = OrdersAccountingDB::new(&db_tx);
+    orders_accounting::calculate_fill_order(
+        &orders_db,
+        *order_id,
+        fill_amount_in_ask_currency,
+        orders_version,
+    )
+    .unwrap()
+}