1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.

//! Substrate statement store API.

use codec::{Decode, Encode};
use jsonrpsee::{
	core::{async_trait, RpcResult},
	Extensions,
};
/// Re-export the API for backward compatibility.
pub use sc_rpc_api::statement::{error::Error, StatementApiServer};
use sp_core::Bytes;
use sp_statement_store::{StatementSource, SubmitResult};
use std::sync::Arc;

/// Statement store API
pub struct StatementStore {
	store: Arc<dyn sp_statement_store::StatementStore>,
}

impl StatementStore {
	/// Create new instance of Offchain API.
	pub fn new(store: Arc<dyn sp_statement_store::StatementStore>) -> Self {
		StatementStore { store }
	}
}

#[async_trait]
impl StatementApiServer for StatementStore {
	fn dump(&self, ext: &Extensions) -> RpcResult<Vec<Bytes>> {
		sc_rpc_api::check_if_safe(ext)?;

		let statements =
			self.store.statements().map_err(|e| Error::StatementStore(e.to_string()))?;
		Ok(statements.into_iter().map(|(_, s)| s.encode().into()).collect())
	}

	fn broadcasts(&self, match_all_topics: Vec<[u8; 32]>) -> RpcResult<Vec<Bytes>> {
		Ok(self
			.store
			.broadcasts(&match_all_topics)
			.map_err(|e| Error::StatementStore(e.to_string()))?
			.into_iter()
			.map(Into::into)
			.collect())
	}

	fn posted(&self, match_all_topics: Vec<[u8; 32]>, dest: [u8; 32]) -> RpcResult<Vec<Bytes>> {
		Ok(self
			.store
			.posted(&match_all_topics, dest)
			.map_err(|e| Error::StatementStore(e.to_string()))?
			.into_iter()
			.map(Into::into)
			.collect())
	}

	fn posted_clear(
		&self,
		match_all_topics: Vec<[u8; 32]>,
		dest: [u8; 32],
	) -> RpcResult<Vec<Bytes>> {
		Ok(self
			.store
			.posted_clear(&match_all_topics, dest)
			.map_err(|e| Error::StatementStore(e.to_string()))?
			.into_iter()
			.map(Into::into)
			.collect())
	}

	fn submit(&self, encoded: Bytes) -> RpcResult<()> {
		let statement = Decode::decode(&mut &*encoded)
			.map_err(|e| Error::StatementStore(format!("Error decoding statement: {:?}", e)))?;
		match self.store.submit(statement, StatementSource::Local) {
			SubmitResult::New(_) | SubmitResult::Known => Ok(()),
			// `KnownExpired` should not happen. Expired statements submitted with
			// `StatementSource::Rpc` should be renewed.
			SubmitResult::KnownExpired =>
				Err(Error::StatementStore("Submitted an expired statement.".into()).into()),
			SubmitResult::Bad(e) => Err(Error::StatementStore(e.into()).into()),
			SubmitResult::Ignored => Err(Error::StatementStore("Store is full.".into()).into()),
			SubmitResult::InternalError(e) => Err(Error::StatementStore(e.to_string()).into()),
		}
	}

	fn remove(&self, hash: [u8; 32]) -> RpcResult<()> {
		Ok(self.store.remove(&hash).map_err(|e| Error::StatementStore(e.to_string()))?)
	}
}