Add GetUtxoReturnAddress RPC scaffolding

cli/src/modules/rpc.rs

@@ -229,6 +229,20 @@ impl Rpc {
                     }
                 }
             }
+            RpcApiOps::GetUtxoReturnAddress => {
+                if argv.is_empty() || argv.len() != 2 {
+                    return Err(Error::custom("Please specify a txid and a accepting_block_daa_score"));
+                }
+
+                let txid = argv.remove(0);
+                let txid = RpcHash::from_hex(txid.as_str())?;
+
+                let accepting_block_daa_score = argv.remove(0).parse::<u64>()?;
+
+                let result = rpc.get_utxo_return_address_call(GetUtxoReturnAddressRequest { txid, accepting_block_daa_score }).await?;
+
+                self.println(&ctx, result);
+            }
             _ => {
                 tprintln!(ctx, "rpc method exists but is not supported by the cli: '{op_str}'\r\n");
                 return Ok(());

components/consensusmanager/src/session.rs

@@ -12,7 +12,7 @@ use kaspa_consensus_core::{
     header::Header,
     pruning::{PruningPointProof, PruningPointTrustedData, PruningPointsList},
     trusted::{ExternalGhostdagData, TrustedBlock},
-    tx::{MutableTransaction, Transaction, TransactionOutpoint, UtxoEntry},
+    tx::{MutableTransaction, ScriptPublicKey, Transaction, TransactionOutpoint, UtxoEntry},
     BlockHashSet, BlueWorkType, ChainPath, Hash,
 };
 use kaspa_utils::sync::rwlock::*;
@@ -291,6 +291,10 @@ impl ConsensusSessionOwned {
         self.clone().spawn_blocking(|c| c.get_chain_block_samples()).await
     }
 
+    pub async fn async_get_utxo_return_address(&self, txid: Hash, accepting_block_daa_score: u64) -> Option<ScriptPublicKey> {
+        self.clone().spawn_blocking(move |c| c.get_utxo_return_address(txid, accepting_block_daa_score)).await
+    }
+
     /// Returns the antipast of block `hash` from the POV of `context`, i.e. `antipast(hash) ∩ past(context)`.
     /// Since this might be an expensive operation for deep blocks, we allow the caller to specify a limit
     /// `max_traversal_allowed` on the maximum amount of blocks to traverse for obtaining the answer

consensus/core/src/api/mod.rs

@@ -18,7 +18,7 @@ use crate::{
     header::Header,
     pruning::{PruningPointProof, PruningPointTrustedData, PruningPointsList},
     trusted::{ExternalGhostdagData, TrustedBlock},
-    tx::{MutableTransaction, Transaction, TransactionOutpoint, UtxoEntry},
+    tx::{MutableTransaction, ScriptPublicKey, Transaction, TransactionOutpoint, UtxoEntry},
     BlockHashSet, BlueWorkType, ChainPath,
 };
 use kaspa_hashes::Hash;
@@ -155,6 +155,10 @@ pub trait ConsensusApi: Send + Sync {
         unimplemented!()
     }
 
+    fn get_utxo_return_address(&self, txid: Hash, daa_score: u64) -> Option<ScriptPublicKey> {
+        unimplemented!()
+    }
+
     fn get_virtual_parents(&self) -> BlockHashSet {
         unimplemented!()
     }

consensus/src/consensus/mod.rs

@@ -49,15 +49,16 @@ use kaspa_consensus_core::{
     errors::{
         coinbase::CoinbaseResult,
         consensus::{ConsensusError, ConsensusResult},
+        difficulty::DifficultyError,
+        pruning::PruningImportError,
         tx::TxResult,
     },
-    errors::{difficulty::DifficultyError, pruning::PruningImportError},
     header::Header,
     muhash::MuHashExtensions,
     network::NetworkType,
     pruning::{PruningPointProof, PruningPointTrustedData, PruningPointsList},
     trusted::{ExternalGhostdagData, TrustedBlock},
-    tx::{MutableTransaction, Transaction, TransactionOutpoint, UtxoEntry},
+    tx::{MutableTransaction, ScriptPublicKey, Transaction, TransactionOutpoint, UtxoEntry},
     BlockHashSet, BlueWorkType, ChainPath,
 };
 use kaspa_consensus_notify::root::ConsensusNotificationRoot;
@@ -610,6 +611,69 @@ impl ConsensusApi for Consensus {
         sample_headers
     }
 
+    fn get_utxo_return_address(&self, txid: Hash, daa_score: u64) -> Option<ScriptPublicKey> {
+        // We need consistency between the past pruning points, selected chain and header store reads
+        let _guard = self.pruning_lock.blocking_read();
+
+        let sc_read = self.selected_chain_store.read();
+
+        let low = self.pruning_point_store.read().get().unwrap().pruning_point;
+        let high = sc_read.get_tip().unwrap().1;
+
+        let mut low_index = sc_read.get_by_hash(low).unwrap();
+        let mut high_index = sc_read.get_by_hash(high).unwrap();
+
+        // let mut locator = Vec::with_capacity((high_index - low_index).ceiling_log_base_2() as usize);
+        // let mut current_index = high_index;
+        let mut matching_chain_block_hash: Option<Hash> = None;
+        while low_index < high_index {
+            let mid = low_index + (high_index - low_index) / 2;
+
+            if let Ok(hash) = sc_read.get_by_index(mid) {
+                if let Ok(compact_header) = self.headers_store.get_compact_header_data(hash) {
+                    if compact_header.daa_score == daa_score {
+                        // We found the chain block we need
+                        matching_chain_block_hash = Some(hash);
+                        break;
+                    } else if compact_header.daa_score < daa_score {
+                        low_index = mid + 1;
+                    } else {
+                        high_index = mid - 1;
+                    }
+                } else {
+                    println!("Did not find a compact header with hash {}", hash);
+                    break;
+                }
+            } else {
+                println!("Did not find a hash at index {}", mid);
+                break;
+            }
+        }
+
+        if matching_chain_block_hash.is_none() {
+            println!("No matching chain block hash found");
+            return None;
+        }
+
+        if let Ok(acceptance_data) = self.acceptance_data_store.get(matching_chain_block_hash.unwrap()) {
+            let containing_acceptance = acceptance_data
+                .iter()
+                .find(|&mbad| mbad.accepted_transactions.iter().find(|&tx| tx.transaction_id == txid).is_some())
+                .cloned();
+
+            if let Some(containing_acceptance) = containing_acceptance {
+                // I found the merged block containing the TXID
+                // let txs = self.block_transactions_store.get(containing_acceptance.block_hash).unwrap().iter().find(|tx| => )
+            } else {
+                return None;
+            }
+
+            return None;
+        } else {
+            return None;
+        };
+    }
+
     fn get_virtual_parents(&self) -> BlockHashSet {
         self.lkg_virtual_state.load().parents.iter().copied().collect()
     }

rpc/core/src/api/ops.rs

@@ -86,6 +86,8 @@ pub enum RpcApiOps {
     GetCoinSupply,
     /// Get DAA Score timestamp estimate
     GetDaaScoreTimestampEstimate,
+    /// Get UTXO Return Addresses
+    GetUtxoReturnAddress,
 
     // Subscription commands for starting/stopping notifications
     NotifyBlockAdded,

rpc/core/src/api/rpc.rs

@@ -304,6 +304,11 @@ pub trait RpcApi: Sync + Send + AnySync {
         request: GetDaaScoreTimestampEstimateRequest,
     ) -> RpcResult<GetDaaScoreTimestampEstimateResponse>;
 
+    async fn get_utxo_return_address(&self, txid: RpcHash, accepting_block_daa_score: u64) -> RpcResult<Option<RpcAddress>> {
+        Ok(self.get_utxo_return_address_call(GetUtxoReturnAddressRequest { txid, accepting_block_daa_score }).await?.return_address)
+    }
+    async fn get_utxo_return_address_call(&self, request: GetUtxoReturnAddressRequest) -> RpcResult<GetUtxoReturnAddressResponse>;
+
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Notification API
 

rpc/core/src/model/message.rs

@@ -823,6 +823,31 @@ impl GetDaaScoreTimestampEstimateResponse {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize, BorshSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct GetUtxoReturnAddressRequest {
+    pub txid: RpcHash,
+    pub accepting_block_daa_score: u64,
+}
+
+impl GetUtxoReturnAddressRequest {
+    pub fn new(txid: RpcHash, accepting_block_daa_score: u64) -> Self {
+        Self { txid, accepting_block_daa_score }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize, BorshSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct GetUtxoReturnAddressResponse {
+    pub return_address: Option<RpcAddress>,
+}
+
+impl GetUtxoReturnAddressResponse {
+    pub fn new(return_address: Option<RpcAddress>) -> Self {
+        Self { return_address }
+    }
+}
+
 // ----------------------------------------------------------------------------
 // Subscriptions & notifications
 // ----------------------------------------------------------------------------

rpc/grpc/client/src/lib.rs

@@ -225,6 +225,7 @@ impl RpcApi for GrpcClient {
     route!(get_mempool_entries_by_addresses_call, GetMempoolEntriesByAddresses);
     route!(get_coin_supply_call, GetCoinSupply);
     route!(get_daa_score_timestamp_estimate_call, GetDaaScoreTimestampEstimate);
+    route!(get_utxo_return_address_call, GetUtxoReturnAddress);
 
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Notification API

rpc/grpc/core/proto/messages.proto

@@ -58,7 +58,8 @@ message KaspadRequest {
     GetMetricsRequestMessage getMetricsRequest = 1090;
     GetServerInfoRequestMessage getServerInfoRequest = 1092;
     GetSyncStatusRequestMessage getSyncStatusRequest = 1094;
-    GetDaaScoreTimestampEstimateRequestMessage GetDaaScoreTimestampEstimateRequest = 1096;
+    GetDaaScoreTimestampEstimateRequestMessage getDaaScoreTimestampEstimateRequest = 1096;
+    GetUtxoReturnAddressRequestMessage GetUtxoReturnAddressRequest = 1098;
   }
 }
 
@@ -117,7 +118,8 @@ message KaspadResponse {
     GetMetricsResponseMessage getMetricsResponse= 1091;
     GetServerInfoResponseMessage getServerInfoResponse = 1093;
     GetSyncStatusResponseMessage getSyncStatusResponse = 1095;
-    GetDaaScoreTimestampEstimateResponseMessage GetDaaScoreTimestampEstimateResponse = 1097;
+    GetDaaScoreTimestampEstimateResponseMessage getDaaScoreTimestampEstimateResponse = 1097;
+    GetUtxoReturnAddressResponseMessage GetUtxoReturnAddressResponse = 1099;
   }
 }
 

rpc/grpc/core/proto/rpc.proto

@@ -844,10 +844,20 @@ message GetSyncStatusResponseMessage{
 }
 
 message GetDaaScoreTimestampEstimateRequestMessage {
-        repeated uint64 daa_scores = 1;
+  repeated uint64 daa_scores = 1;
 }
 
-message GetDaaScoreTimestampEstimateResponseMessage{
-        repeated uint64 timestamps = 1;
-        RPCError error = 1000;
+message GetDaaScoreTimestampEstimateResponseMessage {
+  repeated uint64 timestamps = 1;
+  RPCError error = 1000;
+}
+
+message GetUtxoReturnAddressRequestMessage {
+  string txid = 1;
+  uint64 accepting_block_daa_score = 2;
 }
+
+message GetUtxoReturnAddressResponseMessage {
+  string return_address = 1;
+  RPCError error = 1000;
+}

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

@@ -57,6 +57,7 @@ pub mod kaspad_request_convert {
     impl_into_kaspad_request!(GetServerInfo);
     impl_into_kaspad_request!(GetSyncStatus);
     impl_into_kaspad_request!(GetDaaScoreTimestampEstimate);
+    impl_into_kaspad_request!(GetUtxoReturnAddress);
 
     impl_into_kaspad_request!(NotifyBlockAdded);
     impl_into_kaspad_request!(NotifyNewBlockTemplate);
@@ -188,6 +189,7 @@ pub mod kaspad_response_convert {
     impl_into_kaspad_response!(GetServerInfo);
     impl_into_kaspad_response!(GetSyncStatus);
     impl_into_kaspad_response!(GetDaaScoreTimestampEstimate);
+    impl_into_kaspad_response!(GetUtxoReturnAddress);
 
     impl_into_kaspad_notify_response!(NotifyBlockAdded);
     impl_into_kaspad_notify_response!(NotifyNewBlockTemplate);

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

@@ -19,7 +19,7 @@
 //! The SubmitBlockResponse is a notable exception to this general rule.
 
 use crate::protowire::{self, submit_block_response_message::RejectReason};
-use kaspa_consensus_core::network::NetworkId;
+use kaspa_consensus_core::{network::NetworkId, Hash};
 use kaspa_core::debug;
 use kaspa_notify::subscription::Command;
 use kaspa_rpc_core::{
@@ -394,6 +394,21 @@ from!(item: RpcResult<&kaspa_rpc_core::GetDaaScoreTimestampEstimateResponse>, pr
     Self { timestamps: item.timestamps.clone(), error: None }
 });
 
+from!(item: &kaspa_rpc_core::GetUtxoReturnAddressRequest, protowire::GetUtxoReturnAddressRequestMessage, {
+    Self {
+        txid: item.txid.to_string(),
+        accepting_block_daa_score: item.accepting_block_daa_score
+    }
+});
+from!(item: RpcResult<&kaspa_rpc_core::GetUtxoReturnAddressResponse>, protowire::GetUtxoReturnAddressResponseMessage, {
+    if let Some(return_address) = &item.return_address {
+        Self { return_address: return_address.into(), error: None }
+    } else {
+        Self { return_address: String::from(""), error: None }
+    }
+
+});
+
 from!(&kaspa_rpc_core::PingRequest, protowire::PingRequestMessage);
 from!(RpcResult<&kaspa_rpc_core::PingResponse>, protowire::PingResponseMessage);
 
@@ -791,6 +806,18 @@ try_from!(item: &protowire::GetDaaScoreTimestampEstimateResponseMessage, RpcResu
     Self { timestamps: item.timestamps.clone() }
 });
 
+try_from!(item: &protowire::GetUtxoReturnAddressRequestMessage, kaspa_rpc_core::GetUtxoReturnAddressRequest , {
+    Self {
+        txid: if let Ok(txid) = Hash::from_str(&item.txid) { txid } else { Hash::default() },
+        accepting_block_daa_score: item.accepting_block_daa_score
+    }
+});
+try_from!(item: &protowire::GetUtxoReturnAddressResponseMessage, RpcResult<kaspa_rpc_core::GetUtxoReturnAddressResponse>, {
+    // Self { return_address: Some(Address::from(item.return_address)) }
+    // TODO: import Address
+    Self { return_address: None }
+});
+
 try_from!(&protowire::PingRequestMessage, kaspa_rpc_core::PingRequest);
 try_from!(&protowire::PingResponseMessage, RpcResult<kaspa_rpc_core::PingResponse>);
 

rpc/grpc/core/src/ops.rs

@@ -81,6 +81,7 @@ pub enum KaspadPayloadOps {
     GetServerInfo,
     GetSyncStatus,
     GetDaaScoreTimestampEstimate,
+    GetUtxoReturnAddress,
 
     // Subscription commands for starting/stopping notifications
     NotifyBlockAdded,

rpc/grpc/server/src/request_handler/factory.rs

@@ -75,6 +75,7 @@ impl Factory {
                 GetServerInfo,
                 GetSyncStatus,
                 GetDaaScoreTimestampEstimate,
+                GetUtxoReturnAddress,
                 NotifyBlockAdded,
                 NotifyNewBlockTemplate,
                 NotifyFinalityConflict,

rpc/grpc/server/src/tests/rpc_core_mock.rs

@@ -218,6 +218,10 @@ impl RpcApi for RpcCoreMock {
         Err(RpcError::NotImplemented)
     }
 
+    async fn get_utxo_return_address_call(&self, _request: GetUtxoReturnAddressRequest) -> RpcResult<GetUtxoReturnAddressResponse> {
+        Err(RpcError::NotImplemented)
+    }
+
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     // Notification API
 

rpc/service/src/service.rs

@@ -620,6 +620,13 @@ NOTE: This error usually indicates an RPC conversion error between the node and
         Ok(GetDaaScoreTimestampEstimateResponse::new(timestamps))
     }
 
+    async fn get_utxo_return_address_call(&self, request: GetUtxoReturnAddressRequest) -> RpcResult<GetUtxoReturnAddressResponse> {
+        // let session = self.consensus_manager.consensus().session().await;
+        println!("{} {}", request.txid, request.accepting_block_daa_score);
+        // let mut maybe_spk = session.async_get_utxo_return_address(request.txid, request.accepting_block_daa_score).await;
+        Ok(GetUtxoReturnAddressResponse { return_address: None })
+    }
+
     async fn ping_call(&self, _: PingRequest) -> RpcResult<PingResponse> {
         Ok(PingResponse {})
     }

rpc/wrpc/client/src/client.rs

@@ -414,6 +414,7 @@ impl RpcApi for KaspaRpcClient {
             GetCoinSupply,
             GetConnectedPeerInfo,
             GetDaaScoreTimestampEstimate,
+            GetUtxoReturnAddress,
             GetServerInfo,
             GetCurrentNetwork,
             GetHeaders,

rpc/wrpc/server/src/router.rs

@@ -45,6 +45,7 @@ impl Router {
                 GetCoinSupply,
                 GetConnectedPeerInfo,
                 GetDaaScoreTimestampEstimate,
+                GetUtxoReturnAddress,
                 GetServerInfo,
                 GetCurrentNetwork,
                 GetHeaders,