Sighash input commitments v1

Author: ImplOfAnImpl

Cargo.lock

@@ -246,6 +246,11 @@ hickory-client = "0.24"
 hickory-server = "0.24"
 zeroize = "1.5"
 
+[workspace.dependencies.trezor-client]
+git = "https://github.com/mintlayer/mintlayer-trezor-firmware"
+rev = "967023d82f33984961c8f8fd221672c233b22220" # sighash_input_commitments branch
+features = ["bitcoin", "mintlayer"]
+
 [workspace.metadata.dist.dependencies.apt]
 "libatk1.0-0" = "*"
 "libatk1.0-dev" = "*"

Cargo.toml

@@ -17,6 +17,7 @@ mod simulation;
 
 use std::{
     borrow::Cow,
+    collections::BTreeMap,
     convert::Infallible,
     sync::{Arc, Mutex},
     time::Duration,
@@ -45,17 +46,17 @@ use common::{
             },
             sighash::{
                 input_commitments::{
-                    make_sighash_input_commitments_for_transaction_inputs, SighashInputCommitment,
-                    TrivialUtxoProvider,
+                    make_sighash_input_commitments_for_transaction_inputs_at_height, OrderInfo,
+                    PoolInfo, SighashInputCommitment, TrivialUtxoProvider,
                 },
                 sighashtype::SigHashType,
                 signature_hash,
             },
         },
         stakelock::StakePoolData,
         timelock::OutputTimeLock,
-        CoinUnit, Destination, OutPointSourceId, PoolId, SignedTransaction, TxInput, TxOutput,
-        UtxoOutPoint,
+        CoinUnit, Destination, OrderId, OutPointSourceId, PoolId, SignedTransaction, TxInput,
+        TxOutput, UtxoOutPoint,
     },
     primitives::{per_thousand::PerThousand, Amount, CoinOrTokenId, Idable, H256},
 };
@@ -567,9 +568,29 @@ async fn compare_pool_rewards_with_chainstate_real_state(#[case] seed: Seed) {
         .build();
 
     let utxos = [Some(coin_tx_out), Some(from_block_output)];
-    let input_commitments = make_sighash_input_commitments_for_transaction_inputs(
+    let decommissioned_pool_staker_balance = local_state
+        .storage()
+        .transaction_ro()
+        .await
+        .unwrap()
+        .get_pool_data(pool_id)
+        .await
+        .unwrap()
+        .unwrap()
+        .staker_balance()
+        .unwrap();
+    let input_commitments = make_sighash_input_commitments_for_transaction_inputs_at_height(
         &[input1, input2],
         &TrivialUtxoProvider(&utxos),
+        &BTreeMap::<PoolId, PoolInfo>::from([(
+            pool_id,
+            PoolInfo {
+                staker_balance: decommissioned_pool_staker_balance,
+            },
+        )]),
+        &BTreeMap::<OrderId, OrderInfo>::new(),
+        &chain_config,
+        tf.next_block_height(),
     )
     .unwrap();
     let sighash = signature_hash(

api-server/scanner-lib/src/sync/tests/mod.rs

@@ -170,9 +170,13 @@ impl BanScore for tx_verifier::error::InputCheckErrorPayload {
     fn ban_score(&self) -> u32 {
         match self {
             Self::MissingUtxo(_) => 100,
+            Self::PoolNotFound(_) => 100,
+            Self::OrderNotFound(_) => 100,
             Self::NonUtxoKernelInput(_) => 100,
             Self::UtxoView(e) => e.ban_score(),
             Self::UtxoInfoProvider(e) => e.ban_score(),
+            Self::PoolInfoProvider(e) => e.ban_score(),
+            Self::OrderInfoProvider(e) => e.ban_score(),
             Self::Translation(e) => e.ban_score(),
             Self::Verification(e) => e.ban_score(),
         }

chainstate/src/detail/ban_score.rs

@@ -346,11 +346,14 @@ impl BlockProcessingErrorClassification for tx_verifier::error::InputCheckError
 impl BlockProcessingErrorClassification for tx_verifier::error::InputCheckErrorPayload {
     fn classify(&self) -> BlockProcessingErrorClass {
         match self {
-            Self::MissingUtxo(_) | Self::NonUtxoKernelInput(_) => {
-                BlockProcessingErrorClass::BadBlock
-            }
+            Self::MissingUtxo(_)
+            | Self::PoolNotFound(_)
+            | Self::OrderNotFound(_)
+            | Self::NonUtxoKernelInput(_) => BlockProcessingErrorClass::BadBlock,
             Self::UtxoView(e) => e.classify(),
             Self::UtxoInfoProvider(e) => e.classify(),
+            Self::PoolInfoProvider(e) => e.classify(),
+            Self::OrderInfoProvider(e) => e.classify(),
             Self::Translation(e) => e.classify(),
             Self::Verification(e) => e.classify(),
         }

chainstate/src/detail/error_classification.rs

@@ -185,13 +185,21 @@ impl<'f> BlockBuilder<'f> {
             let destination_getter = SignatureDestinationGetter::new_for_transaction(
                 &tokens_db, &pos_db, &orders_db, &utxo_set,
             );
+            let block_height = self
+                .framework
+                .gen_block_index(&self.prev_block_hash)
+                .block_height()
+                .next_height();
             let witnesses = sign_witnesses(
                 rng,
                 &self.framework.key_manager,
                 self.framework.chainstate.get_chain_config(),
                 &tx,
                 &utxo_set,
+                &pos_db,
+                &orders_db,
                 destination_getter,
+                block_height,
             );
             let tx = SignedTransaction::new(tx, witnesses).expect("invalid witness count");
 

chainstate/test-framework/src/block_builder.rs

@@ -15,28 +15,15 @@
 
 use std::{collections::BTreeMap, sync::Arc};
 
-use chainstate_storage::{
-    BlockchainStorageRead, BlockchainStorageWrite, TransactionRw, Transactional,
-};
 use rstest::rstest;
 
-use crate::{
-    framework_builder::TestFrameworkBuilderValue,
-    get_output_value,
-    key_manager::KeyManager,
-    pos_block_builder::PoSBlockBuilder,
-    random_tx_maker::StakingPoolsObserver,
-    staking_pools::StakingPools,
-    utils::{
-        assert_block_index_opt_identical_to, assert_gen_block_index_identical_to,
-        assert_gen_block_index_opt_identical_to, find_create_pool_tx_in_genesis,
-        outputs_from_block, outputs_from_genesis, SighashInputCommitmentInfoProvider,
-    },
-    BlockBuilder, TestChainstate, TestFrameworkBuilder, TestStore, TxVerificationStrategy,
-};
 use chainstate::{chainstate_interface::ChainstateInterface, BlockSource, ChainstateError};
+use chainstate_storage::{
+    BlockchainStorageRead, BlockchainStorageWrite, TransactionRw, Transactional,
+};
 use chainstate_types::{
     pos_randomness::PoSRandomness, BlockIndex, BlockStatus, EpochStorageRead as _, GenBlockIndex,
+    TipStorageTag,
 };
 use common::{
     chain::{
@@ -48,10 +35,27 @@ use common::{
     time_getter::TimeGetter,
 };
 use crypto::{key::PrivateKey, vrf::VRFPrivateKey};
+use orders_accounting::OrdersAccountingDB;
+use pos_accounting::{PoSAccountingDB, PoSAccountingData};
 use randomness::{CryptoRng, Rng};
 use utils::atomics::SeqCstAtomicU64;
 use utxo::{Utxo, UtxosDB};
 
+use crate::{
+    framework_builder::TestFrameworkBuilderValue,
+    get_output_value,
+    key_manager::KeyManager,
+    pos_block_builder::PoSBlockBuilder,
+    random_tx_maker::StakingPoolsObserver,
+    staking_pools::StakingPools,
+    utils::{
+        assert_block_index_opt_identical_to, assert_gen_block_index_identical_to,
+        assert_gen_block_index_opt_identical_to, find_create_pool_tx_in_genesis,
+        outputs_from_block, outputs_from_genesis, SighashInputCommitmentInfoProvider,
+    },
+    BlockBuilder, TestChainstate, TestFrameworkBuilder, TestStore, TxVerificationStrategy,
+};
+
 /// The `Chainstate` wrapper that simplifies operations and checks in the tests.
 #[must_use]
 pub struct TestFramework {
@@ -587,13 +591,20 @@ impl TestFramework {
     pub fn make_sighash_input_commitments_for_transaction_inputs(
         &self,
         inputs: &[TxInput],
+        block_height: BlockHeight,
     ) -> Vec<SighashInputCommitment<'static>> {
         let storage_tx = self.storage.transaction_ro().unwrap();
         let utxo_db = UtxosDB::new(&storage_tx);
+        let pos_db = PoSAccountingDB::<_, TipStorageTag>::new(&storage_tx);
+        let orders_db = OrdersAccountingDB::new(&storage_tx);
 
-        sighash::input_commitments::make_sighash_input_commitments_for_transaction_inputs(
+        sighash::input_commitments::make_sighash_input_commitments_for_transaction_inputs_at_height(
             inputs,
             &SighashInputCommitmentInfoProvider(&utxo_db),
+            &SighashInputCommitmentInfoProvider(&pos_db),
+            &SighashInputCommitmentInfoProvider(&orders_db),
+            self.chain_config(),
+            block_height,
         )
         .unwrap()
     }
@@ -613,6 +624,38 @@ impl TestFramework {
     pub fn coin_amount_from_utxo(&self, outpoint: &UtxoOutPoint) -> Amount {
         get_output_value(self.utxo(outpoint).output()).unwrap().coin_amount().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
+    }
 }
 
 #[rstest]

chainstate/test-framework/src/framework.rs

@@ -411,13 +411,21 @@ impl<'f> PoSBlockBuilder<'f> {
             let destination_getter = SignatureDestinationGetter::new_for_transaction(
                 &tokens_db, &pos_db, &orders_db, &utxo_set,
             );
+            let block_height = self
+                .framework
+                .gen_block_index(&self.prev_block_hash)
+                .block_height()
+                .next_height();
             let witnesses = sign_witnesses(
                 rng,
                 &self.framework.key_manager,
                 self.framework.chainstate.get_chain_config(),
                 &tx,
                 &utxo_set,
+                &pos_db,
+                &orders_db,
                 destination_getter,
+                block_height,
             );
             let tx = SignedTransaction::new(tx, witnesses).expect("invalid witness count");