Add a summary of the signed transaction

api-server/scanner-lib/src/blockchain_state/mod.rs

@@ -1003,7 +1003,7 @@ async fn update_tables_from_transaction_outputs<T: ApiServerStorageWrite>(
                 increase_address_amount(
                     db_tx,
                     &address,
-                    &stake_pool_data.value(),
+                    &stake_pool_data.pledge(),
                     CoinOrTokenId::Coin,
                     block_height,
                 )

api-server/stack-test-suite/tests/v1/pool.rs

@@ -213,7 +213,7 @@ async fn ok(#[case] seed: Seed) {
         );
         assert_eq!(
             body.get("staker_balance").unwrap(),
-            &serde_json::json!(amount_to_json(pool_data.value()))
+            &serde_json::json!(amount_to_json(pool_data.pledge()))
         );
 
         assert_eq!(

api-server/stack-test-suite/tests/v1/pools.rs

@@ -231,7 +231,7 @@ async fn ok(#[case] seed: Seed) {
             );
             assert_eq!(
                 json.get("staker_balance").unwrap(),
-                &serde_json::json!(amount_to_json(pool_data.value()))
+                &serde_json::json!(amount_to_json(pool_data.pledge()))
             );
 
             assert_eq!(
@@ -253,7 +253,7 @@ async fn ok(#[case] seed: Seed) {
     }
 
     {
-        pools.sort_by_key(|x| Reverse(x.1.value()));
+        pools.sort_by_key(|x| Reverse(x.1.pledge()));
         let items = pools.len();
         let url = format!("/api/v1/pool?sort=by_pledge&items={items}&offset=0");
         // Given that the listener port is open, this will block until a
@@ -283,7 +283,7 @@ async fn ok(#[case] seed: Seed) {
             );
             assert_eq!(
                 json.get("staker_balance").unwrap(),
-                &serde_json::json!(amount_to_json(pool_data.value()))
+                &serde_json::json!(amount_to_json(pool_data.pledge()))
             );
 
             assert_eq!(

api-server/web-server/src/api/json_helpers.rs

@@ -79,7 +79,7 @@ pub fn txoutput_to_json(out: &TxOutput, chain_config: &ChainConfig) -> serde_jso
                 "type": "CreateStakePool",
                 "pool_id": Address::new(chain_config, pool_id).expect("no error").get(),
                 "data": {
-                    "amount": amount_to_json(data.value()),
+                    "amount": amount_to_json(data.pledge()),
                     "staker": Address::new(chain_config, data.staker()).expect("no error").get(),
                     "vrf_public_key": Address::new(chain_config, data.vrf_public_key()).expect("no error").get(),
                     "decommission_key": Address::new(chain_config, data.decommission_key()).expect("no error").get(),

chainstate/constraints-value-accumulator/src/constraints_accumulator.rs

@@ -291,7 +291,7 @@ impl ConstrainedValueAccumulator {
                 TxOutput::CreateStakePool(_, data) => insert_or_increase(
                     &mut accumulator.unconstrained_value,
                     CoinOrTokenId::Coin,
-                    data.value(),
+                    data.pledge(),
                 )?,
                 TxOutput::ProduceBlockFromStake(_, _) | TxOutput::CreateDelegationId(_, _) => {
                     /* do nothing as these outputs cannot produce values */

chainstate/src/interface/chainstate_interface_impl.rs

@@ -649,7 +649,7 @@ fn get_output_coin_amount(
         TxOutput::Transfer(v, _) | TxOutput::LockThenTransfer(v, _, _) | TxOutput::Burn(v) => {
             v.coin_amount()
         }
-        TxOutput::CreateStakePool(_, data) => Some(data.value()),
+        TxOutput::CreateStakePool(_, data) => Some(data.pledge()),
         TxOutput::ProduceBlockFromStake(_, pool_id) => {
             let pledge_amount = pos_accounting_view
                 .get_pool_data(*pool_id)

chainstate/tx-verifier/src/transaction_verifier/mod.rs

@@ -363,15 +363,15 @@ where
                     Some(input_utxo_outpoint) => {
                         let expected_pool_id = pos_accounting::make_pool_id(input_utxo_outpoint);
                         let res = if expected_pool_id == *pool_id {
-                            if data.value() >= self.chain_config.as_ref().min_stake_pool_pledge() {
+                            if data.pledge() >= self.chain_config.as_ref().min_stake_pool_pledge() {
                                 self.pos_accounting_adapter
                                     .operations(tx_source)
                                     .create_pool(*pool_id, data.as_ref().clone().into())
                                     .map_err(ConnectTransactionError::PoSAccountingError)
                             } else {
                                 Err(ConnectTransactionError::NotEnoughPledgeToCreateStakePool(
                                     tx.get_id(),
-                                    data.value(),
+                                    data.pledge(),
                                     self.chain_config.as_ref().min_stake_pool_pledge(),
                                 ))
                             }

common/src/chain/transaction/mod.rs

@@ -39,12 +39,16 @@ pub use output::*;
 
 pub mod signature;
 
+mod printout;
+
 use self::signature::inputsig::InputWitness;
 use self::signed_transaction::SignedTransaction;
 
 mod transaction_v1;
 use transaction_v1::TransactionV1;
 
+use super::ChainConfig;
+
 /// In case multiple types of transactions are developed, the size of that transaction can be described here along with its type
 pub enum TransactionSize {
     ScriptedTransaction(usize),
@@ -139,6 +143,10 @@ impl Transaction {
         }
         SignedTransaction::new(self, witnesses)
     }
+
+    pub fn printable(&self, chain_config: &ChainConfig) -> String {
+        printout::transaction_summary(self, chain_config)
+    }
 }
 
 impl serde::Serialize for Id<Transaction> {

common/src/chain/transaction/output/stakelock.rs

@@ -33,7 +33,7 @@ use super::Destination;
     serde::Deserialize,
 )]
 pub struct StakePoolData {
-    value: Amount,
+    pledge: Amount,
     staker: Destination,
     vrf_public_key: VRFPublicKey,
     decommission_key: Destination,
@@ -43,15 +43,15 @@ pub struct StakePoolData {
 
 impl StakePoolData {
     pub fn new(
-        value: Amount,
+        pledge: Amount,
         staker: Destination,
         vrf_public_key: VRFPublicKey,
         decommission_key: Destination,
         margin_ratio_per_thousand: PerThousand,
         cost_per_block: Amount,
     ) -> Self {
         Self {
-            value,
+            pledge,
             staker,
             vrf_public_key,
             decommission_key,
@@ -80,7 +80,7 @@ impl StakePoolData {
         self.cost_per_block
     }
 
-    pub fn value(&self) -> Amount {
-        self.value
+    pub fn pledge(&self) -> Amount {
+        self.pledge
     }
 }