Move accepted transactions as a top-level vec to VSPC2

GetVirtualChainFromBlockV2Response now has chain_block_accepted_transactions

Author: coderofstuff

rpc/core/src/model/message.rs

@@ -2774,15 +2774,15 @@ pub struct GetVirtualChainFromBlockV2Response {
     /// always present, no matter the verbosity level
     pub added_chain_block_hashes: Arc<Vec<RpcHash>>,
     /// struct properties are optionally returned depending on the verbosity level
-    pub added_acceptance_data: Arc<Vec<RpcAcceptanceData>>,
+    pub chain_block_accepted_transactions: Arc<Vec<RpcChainBlockAcceptedTransactions>>,
 }
 
 impl Serializer for GetVirtualChainFromBlockV2Response {
     fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
         store!(u16, &1, writer)?;
         store!(Vec<RpcHash>, &self.removed_chain_block_hashes, writer)?;
         store!(Vec<RpcHash>, &self.added_chain_block_hashes, writer)?;
-        serialize!(Vec<RpcAcceptanceData>, &self.added_acceptance_data, writer)?;
+        serialize!(Vec<RpcChainBlockAcceptedTransactions>, &self.chain_block_accepted_transactions, writer)?;
         Ok(())
     }
 }
@@ -2792,11 +2792,11 @@ impl Deserializer for GetVirtualChainFromBlockV2Response {
         let _version = load!(u16, reader)?;
         let removed_chain_block_hashes = load!(Vec<RpcHash>, reader)?;
         let added_chain_block_hashes = load!(Vec<RpcHash>, reader)?;
-        let added_acceptance_data = deserialize!(Vec<RpcAcceptanceData>, reader)?;
+        let chain_block_accepted_transactions = deserialize!(Vec<RpcChainBlockAcceptedTransactions>, reader)?;
         Ok(Self {
             removed_chain_block_hashes: removed_chain_block_hashes.into(),
             added_chain_block_hashes: added_chain_block_hashes.into(),
-            added_acceptance_data: added_acceptance_data.into(),
+            chain_block_accepted_transactions: chain_block_accepted_transactions.into(),
         })
     }
 }

rpc/core/src/model/tests.rs

@@ -56,7 +56,8 @@ mod mockery {
     where
         T: Mock,
     {
-        Mock::mock()
+        // forward to the type's Mock implementation
+        T::mock()
     }
 
     // this function tests serialization and deserialization of a type
@@ -1286,7 +1287,7 @@ mod mockery {
             GetVirtualChainFromBlockV2Response {
                 removed_chain_block_hashes: mock(),
                 added_chain_block_hashes: mock(),
-                added_acceptance_data: mock(),
+                chain_block_accepted_transactions: mock(),
             }
         }
     }

rpc/core/src/model/tx.rs

@@ -8,7 +8,10 @@ use kaspa_utils::{hex::ToHex, serde_bytes_fixed_ref};
 use serde::{Deserialize, Serialize};
 use workflow_serializer::prelude::*;
 
-use crate::prelude::{RpcHash, RpcScriptClass, RpcSubnetworkId};
+use crate::{
+    prelude::{RpcHash, RpcScriptClass, RpcSubnetworkId},
+    RpcOptionalHeader, RpcOptionalTransaction,
+};
 
 /// Represents the ID of a Kaspa transaction
 pub type RpcTransactionId = TransactionId;
@@ -398,3 +401,31 @@ pub struct RpcAcceptedTransactionIds {
     pub accepting_block_hash: RpcHash,
     pub accepted_transaction_ids: Vec<RpcTransactionId>,
 }
+
+/// Represents accepted transaction ids
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RpcChainBlockAcceptedTransactions {
+    pub chain_block_header: RpcOptionalHeader,
+    pub accepted_transactions: Vec<RpcOptionalTransaction>,
+}
+
+impl Serializer for RpcChainBlockAcceptedTransactions {
+    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
+        store!(u16, &1, writer)?;
+        serialize!(RpcOptionalHeader, &self.chain_block_header, writer)?;
+        serialize!(Vec<RpcOptionalTransaction>, &self.accepted_transactions, writer)?;
+
+        Ok(())
+    }
+}
+
+impl Deserializer for RpcChainBlockAcceptedTransactions {
+    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
+        let _struct_version = load!(u16, reader)?;
+        let chain_block_header = deserialize!(RpcOptionalHeader, reader)?;
+        let accepted_transactions = deserialize!(Vec<RpcOptionalTransaction>, reader)?;
+
+        Ok(Self { chain_block_header, accepted_transactions })
+    }
+}

rpc/core/src/wasm/message.rs

@@ -44,6 +44,35 @@ const TS_ACCEPTED_TRANSACTION_IDS: &'static str = r#"
     }
 "#;
 
+#[wasm_bindgen(typescript_custom_section)]
+const TS_ADDED_ACCEPTANCE_DATA: &'static str = r#"
+    /**
+     * Accepted Acceptance Data
+     * 
+     * @category Node RPC
+     */
+    export interface IChainBlockAddedTransactions {
+        chainBlockHeader: Header;
+        acceptedTransactions: Transaction[];
+    }
+"#;
+
+// DataVerbosityLevel
+#[wasm_bindgen(typescript_custom_section)]
+const TS_DATA_VERBOSITY_LEVEL: &'static str = r#"
+    /**
+     * Data Verbosity level
+     * 
+     * @category Node RPC
+     */
+    export enum DataVerbosityLevel {
+        None = "None",
+        Low = "Low",
+        High = "High",
+        Full = "Full",
+    }
+"#;
+
 // ---
 
 declare! {
@@ -1263,6 +1292,44 @@ try_from! ( args: GetVirtualChainFromBlockResponse, IGetVirtualChainFromBlockRes
     Ok(to_value(&args)?.into())
 });
 
+declare! {
+    IGetVirtualChainFromBlockV2Request,
+    r#"
+    /**
+     * 
+     * 
+     * @category Node RPC
+     */
+    export interface IGetVirtualChainFromBlockV2Request {
+        startHash : HexString;
+        dataVerbosityLevel?: string;
+    }
+    "#,
+}
+
+try_from! ( args: IGetVirtualChainFromBlockV2Request, GetVirtualChainFromBlockV2Request, {
+    Ok(from_value(args.into())?)
+});
+
+declare! {
+    IGetVirtualChainFromBlockV2Response,
+    r#"
+    /**
+     * 
+     * 
+     * @category Node RPC
+     */
+    export interface IGetVirtualChainFromBlockV2Response {
+        removedChainBlockHashes : HexString[];
+        addedChainBlockHashes : HexString[];
+        chainBlockAcceptedTransactions : IChainBlockAddedTransactions[];
+    }
+    "#,
+}
+
+try_from! ( args: GetVirtualChainFromBlockV2Response, IGetVirtualChainFromBlockV2Response, {
+    Ok(to_value(&args)?.into())
+});
 // ---
 
 declare! {

rpc/grpc/core/proto/rpc.proto

@@ -121,6 +121,11 @@ message RpcTransactionOutputVerboseData{
   string scriptPublicKeyAddress = 6;
 }
 
+message RpcChainBlockAcceptedTransactions {
+  RpcBlockHeader chainBlockHeader = 1;
+  repeated RpcTransaction acceptedTransactions = 2;
+}
+
 enum RpcNotifyCommand {
   NOTIFY_START = 0;
   NOTIFY_STOP = 1;
@@ -1029,7 +1034,7 @@ message GetVirtualChainFromBlockV2ResponseMessage{
 
   // The mergeset data accepted by each block in addedChainBlockHashes.
   // Will be filled dependent on the supplied RpcAcceptanceDataVerbosity.
-  repeated RpcAcceptanceData addedAcceptanceData = 3;
+  repeated RpcChainBlockAcceptedTransactions chainBlockAcceptedTransactions = 3;
 
   RPCError error = 1000;
 }

rpc/grpc/core/src/convert/message.rs

@@ -527,7 +527,7 @@ from!(item: RpcResult<&kaspa_rpc_core::GetVirtualChainFromBlockV2Response>, prot
     Self {
         removed_chain_block_hashes: item.removed_chain_block_hashes.iter().map(|x| x.to_string()).collect(),
         added_chain_block_hashes: item.added_chain_block_hashes.iter().map(|x| x.to_string()).collect(),
-        added_acceptance_data: item.added_acceptance_data.iter().map(|x| x.into()).collect(),
+        chain_block_accepted_transactions: item.chain_block_accepted_transactions.iter().map(|x| x.into()).collect(),
         error: None,
     }
 });
@@ -795,7 +795,7 @@ try_from!(item: &protowire::GetVirtualChainFromBlockV2ResponseMessage, RpcResult
     Self {
         removed_chain_block_hashes: Arc::new(item.removed_chain_block_hashes.iter().map(|x| RpcHash::from_str(x)).collect::<Result<Vec<_>, _>>()?),
         added_chain_block_hashes: Arc::new(item.added_chain_block_hashes.iter().map(|x| RpcHash::from_str(x)).collect::<Result<Vec<_>, _>>()?),
-        added_acceptance_data: Arc::new(item.added_acceptance_data.iter().map(|x| x.try_into()).collect::<Result<Vec<_>, _>>()?),
+        chain_block_accepted_transactions: Arc::new(item.chain_block_accepted_transactions.iter().map(|x| x.try_into()).collect::<Result<Vec<_>, _>>()?),
     }
 });
 

rpc/grpc/core/src/convert/tx.rs

@@ -1,6 +1,8 @@
 use crate::protowire::{self};
 use crate::{from, try_from};
-use kaspa_rpc_core::{FromRpcHex, RpcAddress, RpcError, RpcHash, RpcResult, RpcScriptClass, RpcScriptVec, ToRpcHex};
+use kaspa_rpc_core::{
+    FromRpcHex, RpcAddress, RpcError, RpcHash, RpcOptionalHeader, RpcResult, RpcScriptClass, RpcScriptVec, ToRpcHex,
+};
 use std::str::FromStr;
 
 // ----------------------------------------------------------------------------
@@ -106,6 +108,13 @@ from!(item: &kaspa_rpc_core::RpcOptionalUtxoEntryVerboseData, protowire::RpcUtxo
     }
 });
 
+from!(item: &kaspa_rpc_core::RpcChainBlockAcceptedTransactions, protowire::RpcChainBlockAcceptedTransactions, {
+    Self {
+        chain_block_header: Some((&item.chain_block_header).into()),
+        accepted_transactions: item.accepted_transactions.iter().map(protowire::RpcTransaction::from).collect(),
+    }
+});
+
 from!(item: &kaspa_rpc_core::RpcScriptPublicKey, protowire::RpcScriptPublicKey, {
     Self { version: item.version().into(), script_public_key: item.script().to_rpc_hex() }
 });
@@ -375,6 +384,13 @@ try_from!(item: &protowire::RpcAcceptedTransactionIds, kaspa_rpc_core::RpcAccept
     }
 });
 
+try_from!(item: &protowire::RpcChainBlockAcceptedTransactions, kaspa_rpc_core::RpcChainBlockAcceptedTransactions, {
+    Self {
+        chain_block_header: RpcOptionalHeader::try_from(item.chain_block_header.as_ref().ok_or_else(|| RpcError::MissingRpcFieldError("RpcChainBlockAcceptedTransactions".to_string(), "chain_block_header".to_string()))?)?,
+        accepted_transactions: item.accepted_transactions.iter().map(kaspa_rpc_core::RpcOptionalTransaction::try_from).collect::<Result<_, _>>()?,
+    }
+});
+
 try_from!(item: &protowire::RpcUtxosByAddressesEntry, kaspa_rpc_core::RpcUtxosByAddressesEntry, {
     let address = if item.address.is_empty() { None } else { Some(item.address.as_str().try_into()?) };
     Self {

rpc/service/src/service.rs

@@ -1271,12 +1271,23 @@ NOTE: This error usually indicates an RPC conversion error between the node and
         let added_acceptance_data =
             self.consensus_converter.get_acceptance_data_with_verbosity(&session, &verbosity, &chain_path, Some(batch_size)).await?;
 
+        let chain_block_accepted_transactions: Vec<_> = added_acceptance_data
+            .iter()
+            .map(|data| {
+                let chain_block_header = data.accepting_chain_header.as_ref().unwrap().clone();
+                // Flatten all accepted transactions from mergeset blocks into a single vec
+                let accepted_transactions: Vec<RpcOptionalTransaction> =
+                    data.mergeset_block_acceptance_data.iter().flat_map(|tx| tx.accepted_transactions.clone()).collect();
+
+                RpcChainBlockAcceptedTransactions { chain_block_header, accepted_transactions }
+            })
+            .collect();
         chain_path.added.truncate(added_acceptance_data.len());
 
         Ok(GetVirtualChainFromBlockV2Response {
             removed_chain_block_hashes: chain_path.removed.into(),
             added_chain_block_hashes: chain_path.added.into(),
-            added_acceptance_data: added_acceptance_data.into(),
+            chain_block_accepted_transactions: chain_block_accepted_transactions.into(),
         })
     }
 

rpc/wrpc/examples/vcc_v2/src/main.rs

@@ -60,31 +60,22 @@ async fn get_vcc_v2() -> Result<()> {
         )
         .await?;
 
-    let mut count_mergeset = 0;
-    let mut count_block = 0;
     let mut seen_tx = HashSet::<RpcHash>::with_capacity(30_000);
     let mut count_duplicated_tx = 0;
 
     println!("{:#?}", response);
-    response.added_acceptance_data.iter().for_each(|acd| {
+    response.chain_block_accepted_transactions.iter().for_each(|acd| {
         // println!("mergeset of {}", acd.accepting_chain_header.as_ref().unwrap().hash.unwrap());
 
-        count_mergeset += 1;
-        acd.mergeset_block_acceptance_data.iter().for_each(|bad| {
-            // println!("block {}", bad.merged_header.as_ref().unwrap().hash.unwrap());
-            count_block += 1;
-
-            bad.accepted_transactions.iter().for_each(|tx| {
-                let id = tx.verbose_data.as_ref().unwrap().transaction_id.unwrap();
-                if seen_tx.contains(&id) {
-                    count_duplicated_tx += 1;
-                }
-                seen_tx.insert(id);
-            });
-        })
+        acd.accepted_transactions.iter().for_each(|tx| {
+            let id = tx.verbose_data.as_ref().unwrap().transaction_id.unwrap();
+            if seen_tx.contains(&id) {
+                count_duplicated_tx += 1;
+            }
+            seen_tx.insert(id);
+        });
     });
 
-    println!("ms: {}, b: {}", count_mergeset, count_block);
     println!("duplicated tx {}", count_duplicated_tx);
     // Disconnect client from Kaspa node
     client.disconnect().await?;

rpc/wrpc/wasm/src/client.rs

@@ -1056,6 +1056,10 @@ build_wrpc_wasm_bindgen_interface!(
         /// Returned information: None.
         Unban,
         /// Get UTXO Return Addresses.
-        GetUtxoReturnAddress
+        GetUtxoReturnAddress,
+        /// Retrieves the virtual chain corresponding to a specified block hash.
+        /// Returned information: Virtual chain information. (Version 2)
+        /// May be used to get fully populated transactions
+        GetVirtualChainFromBlockV2
     ]
 );