15280118615

// Copyright 2025 The Tari Project
// SPDX-License-Identifier: BSD-3-Clause

#[cfg(feature = "base_node")]
mod service;
#[cfg(feature = "base_node")]
pub mod sync_utxos_by_block_task;

pub mod models;

#[cfg(feature = "base_node")]
pub mod query_service;

use std::{error::Error, fmt::Debug};

#[cfg(feature = "base_node")]
pub use service::BaseNodeWalletRpcService;
use tari_comms::protocol::rpc::{Request, Response, RpcStatus, Streaming};
use tari_comms_rpc_macros::tari_rpc;
#[cfg(feature = "base_node")]
use url::Url;

#[cfg(feature = "base_node")]
use crate::base_node::StateMachineHandle;
use crate::{
    blocks::BlockHeader,
    proto,
    proto::{
        base_node::{
            FetchMatchingUtxos,
            FetchUtxosResponse,
            GetMempoolFeePerGramStatsRequest,
            GetMempoolFeePerGramStatsResponse,
            GetWalletQueryHttpServiceAddressResponse,
            QueryDeletedRequest,
            QueryDeletedResponse,
            Signatures,
            SyncUtxosByBlockRequest,
            SyncUtxosByBlockResponse,
            TipInfoResponse,
            TxQueryBatchResponses,
            TxQueryResponse,
            TxSubmissionResponse,
            UtxoQueryRequest,
            UtxoQueryResponses,
        },
        types::{Signature, Transaction},
    },
};
#[cfg(feature = "base_node")]
use crate::{
    chain_storage::{async_db::AsyncBlockchainDb, BlockchainBackend},
    mempool::service::MempoolHandle,
};

/// Trait that a base node wallet query service must implement.
/// Please note that this service is to fetch data, so read-only queries.
#[async_trait::async_trait]
pub trait BaseNodeWalletQueryService: Send + Sync + 'static {
    type Error: Error + 'static;

    async fn get_tip_info(&self) -> Result<models::TipInfoResponse, Self::Error>;

    async fn get_header_by_height(&self, height: u64) -> Result<BlockHeader, Self::Error>;

    async fn get_height_at_time(&self, epoch_time: u64) -> Result<u64, Self::Error>;
}

#[tari_rpc(protocol_name = b"t/bnwallet/1", server_struct = BaseNodeWalletRpcServer, client_struct = BaseNodeWalletRpcClient
)]
pub trait BaseNodeWalletService: Send + Sync + 'static {
    #[rpc(method = 1)]
    async fn submit_transaction(
        &self,
        request: Request<Transaction>,
    ) -> Result<Response<TxSubmissionResponse>, RpcStatus>;

    #[rpc(method = 2)]
    async fn transaction_query(&self, request: Request<Signature>) -> Result<Response<TxQueryResponse>, RpcStatus>;

    #[rpc(method = 3)]
    async fn transaction_batch_query(
        &self,
        request: Request<Signatures>,
    ) -> Result<Response<TxQueryBatchResponses>, RpcStatus>;

    #[rpc(method = 4)]
    async fn fetch_matching_utxos(
        &self,
        request: Request<FetchMatchingUtxos>,
    ) -> Result<Response<FetchUtxosResponse>, RpcStatus>;

    #[rpc(method = 5)]
    async fn get_tip_info(&self, request: Request<()>) -> Result<Response<TipInfoResponse>, RpcStatus>;

    #[rpc(method = 6)]
    async fn get_header(&self, request: Request<u64>) -> Result<Response<proto::core::BlockHeader>, RpcStatus>;

    #[rpc(method = 7)]
    async fn utxo_query(&self, request: Request<UtxoQueryRequest>) -> Result<Response<UtxoQueryResponses>, RpcStatus>;

    #[rpc(method = 8)]
    async fn query_deleted(
        &self,
        request: Request<QueryDeletedRequest>,
    ) -> Result<Response<QueryDeletedResponse>, RpcStatus>;

    #[rpc(method = 9)]
    async fn get_header_by_height(
        &self,
        request: Request<u64>,
    ) -> Result<Response<proto::core::BlockHeader>, RpcStatus>;

    #[rpc(method = 10)]
    async fn get_height_at_time(&self, request: Request<u64>) -> Result<Response<u64>, RpcStatus>;

    #[rpc(method = 11)]
    async fn sync_utxos_by_block(
        &self,
        request: Request<SyncUtxosByBlockRequest>,
    ) -> Result<Streaming<SyncUtxosByBlockResponse>, RpcStatus>;

    #[rpc(method = 12)]
    async fn get_mempool_fee_per_gram_stats(
        &self,
        request: Request<GetMempoolFeePerGramStatsRequest>,
    ) -> Result<Response<GetMempoolFeePerGramStatsResponse>, RpcStatus>;

    #[rpc(method = 13)]
    async fn get_wallet_query_http_service_address(
        &self,
        request: Request<()>,
    ) -> Result<Response<GetWalletQueryHttpServiceAddressResponse>, RpcStatus>;
}

#[cfg(feature = "base_node")]
pub fn create_base_node_wallet_rpc_service<B: BlockchainBackend + 'static>(
    db: AsyncBlockchainDb<B>,
    mempool: MempoolHandle,
    state_machine: StateMachineHandle,
    wallet_query_service_address: Option<Url>,
) -> BaseNodeWalletRpcServer<BaseNodeWalletRpcService<B>> {
    BaseNodeWalletRpcServer::new(BaseNodeWalletRpcService::new(
        db,
        mempool,
        state_machine,
        wallet_query_service_address,
    ))
}

1	// Copyright 2025 The Tari Project
2	// SPDX-License-Identifier: BSD-3-Clause
3
4	#[cfg(feature = "base_node")]
5	mod service;
6	#[cfg(feature = "base_node")]
7	pub mod sync_utxos_by_block_task;
8
9	pub mod models;
10
11	#[cfg(feature = "base_node")]
12	pub mod query_service;
13
14	use std::{error::Error, fmt::Debug};
15
16	#[cfg(feature = "base_node")]
17	pub use service::BaseNodeWalletRpcService;
18	use tari_comms::protocol::rpc::{Request, Response, RpcStatus, Streaming};
19	use tari_comms_rpc_macros::tari_rpc;
20	#[cfg(feature = "base_node")]
21	use url::Url;
22
23	#[cfg(feature = "base_node")]
24	use crate::base_node::StateMachineHandle;
25	use crate::{
26	blocks::BlockHeader,
27	proto,
28	proto::{
29	base_node::{
30	FetchMatchingUtxos,
31	FetchUtxosResponse,
32	GetMempoolFeePerGramStatsRequest,
33	GetMempoolFeePerGramStatsResponse,
34	GetWalletQueryHttpServiceAddressResponse,
35	QueryDeletedRequest,
36	QueryDeletedResponse,
37	Signatures,
38	SyncUtxosByBlockRequest,
39	SyncUtxosByBlockResponse,
40	TipInfoResponse,
41	TxQueryBatchResponses,
42	TxQueryResponse,
43	TxSubmissionResponse,
44	UtxoQueryRequest,
45	UtxoQueryResponses,
46	},
47	types::{Signature, Transaction},
48	},
49	};
50	#[cfg(feature = "base_node")]
51	use crate::{
52	chain_storage::{async_db::AsyncBlockchainDb, BlockchainBackend},
53	mempool::service::MempoolHandle,
54	};
55
56	/// Trait that a base node wallet query service must implement.
57	/// Please note that this service is to fetch data, so read-only queries.
58	#[async_trait::async_trait]
59	pub trait BaseNodeWalletQueryService: Send + Sync + 'static {
60	type Error: Error + 'static;
61
62	async fn get_tip_info(&self) -> Result<models::TipInfoResponse, Self::Error>;
63
64	async fn get_header_by_height(&self, height: u64) -> Result<BlockHeader, Self::Error>;
65
66	async fn get_height_at_time(&self, epoch_time: u64) -> Result<u64, Self::Error>;
67	}
68
69	#[tari_rpc(protocol_name = b"t/bnwallet/1", server_struct = BaseNodeWalletRpcServer, client_struct = BaseNodeWalletRpcClient	349✔
70	)]	349✔
71	pub trait BaseNodeWalletService: Send + Sync + 'static {
72	#[rpc(method = 1)]
73	async fn submit_transaction(
74	&self,
75	request: Request<Transaction>,
76	) -> Result<Response<TxSubmissionResponse>, RpcStatus>;
77
78	#[rpc(method = 2)]
79	async fn transaction_query(&self, request: Request<Signature>) -> Result<Response<TxQueryResponse>, RpcStatus>;
80
81	#[rpc(method = 3)]
82	async fn transaction_batch_query(
83	&self,
84	request: Request<Signatures>,
85	) -> Result<Response<TxQueryBatchResponses>, RpcStatus>;
86
87	#[rpc(method = 4)]
88	async fn fetch_matching_utxos(
89	&self,
90	request: Request<FetchMatchingUtxos>,
91	) -> Result<Response<FetchUtxosResponse>, RpcStatus>;
92
93	#[rpc(method = 5)]
94	async fn get_tip_info(&self, request: Request<()>) -> Result<Response<TipInfoResponse>, RpcStatus>;
95
96	#[rpc(method = 6)]
97	async fn get_header(&self, request: Request<u64>) -> Result<Response<proto::core::BlockHeader>, RpcStatus>;
98
99	#[rpc(method = 7)]
100	async fn utxo_query(&self, request: Request<UtxoQueryRequest>) -> Result<Response<UtxoQueryResponses>, RpcStatus>;
101
102	#[rpc(method = 8)]
103	async fn query_deleted(
104	&self,
105	request: Request<QueryDeletedRequest>,
106	) -> Result<Response<QueryDeletedResponse>, RpcStatus>;
107
108	#[rpc(method = 9)]
109	async fn get_header_by_height(
110	&self,
111	request: Request<u64>,
112	) -> Result<Response<proto::core::BlockHeader>, RpcStatus>;
113
114	#[rpc(method = 10)]
115	async fn get_height_at_time(&self, request: Request<u64>) -> Result<Response<u64>, RpcStatus>;
116
117	#[rpc(method = 11)]
118	async fn sync_utxos_by_block(
119	&self,
120	request: Request<SyncUtxosByBlockRequest>,
121	) -> Result<Streaming<SyncUtxosByBlockResponse>, RpcStatus>;
122
123	#[rpc(method = 12)]
124	async fn get_mempool_fee_per_gram_stats(
125	&self,
126	request: Request<GetMempoolFeePerGramStatsRequest>,
127	) -> Result<Response<GetMempoolFeePerGramStatsResponse>, RpcStatus>;
128
129	#[rpc(method = 13)]
130	async fn get_wallet_query_http_service_address(
131	&self,
132	request: Request<()>,
133	) -> Result<Response<GetWalletQueryHttpServiceAddressResponse>, RpcStatus>;
134	}
135
136	#[cfg(feature = "base_node")]
137	pub fn create_base_node_wallet_rpc_service<B: BlockchainBackend + 'static>(	×
138	db: AsyncBlockchainDb<B>,	×
139	mempool: MempoolHandle,	×
140	state_machine: StateMachineHandle,	×
NEW 141	wallet_query_service_address: Option<Url>,	×
142	) -> BaseNodeWalletRpcServer<BaseNodeWalletRpcService<B>> {	×
NEW 143	BaseNodeWalletRpcServer::new(BaseNodeWalletRpcService::new(	×
NEW 144	db,	×
NEW 145	mempool,	×
NEW 146	state_machine,	×
NEW 147	wallet_query_service_address,	×
NEW 148	))	×
UNCOV 149	}	×

tari-project / tari / 15280118615

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous