Feat/add vtoken exchange rate rpc (#1274)

* Add vtoken exchange rate rpc

* add the use of Vec

* supplement the RPC logic && fix bugs

* adjust the RPC exchange rate precision to three decimal places

* fix clippy

Cargo.toml

@@ -52,6 +52,7 @@ bifrost-salp-rpc         = { path = "pallets/salp/rpc" }
 bifrost-stable-pool-rpc  = { path = "pallets/stable-pool/rpc" }
 bifrost-ve-minting-rpc   = { path = "pallets/ve-minting/rpc" }
 lend-market-rpc          = { path = "pallets/lend-market/rpc" }
+bifrost-vtoken-minting-rpc = { path = "pallets/vtoken-minting/rpc" }
 
 # Bifrost Runtime
 bifrost-kusama-runtime   = { path = "runtime/bifrost-kusama" }

node/rpc/Cargo.toml

@@ -37,4 +37,6 @@ zenlink-protocol-rpc = { workspace = true }
 zenlink-protocol-runtime-api = { workspace = true }
 zenlink-stable-amm-rpc = { workspace = true }
 zenlink-stable-amm-runtime-api = { workspace = true }
+bifrost-vtoken-minting-rpc = { workspace = true }
+bifrost-vtoken-minting-rpc-runtime-api = { workspace = true }
 

node/rpc/src/lib.rs

@@ -44,6 +44,8 @@ use bifrost_stable_pool_rpc::{StablePoolRpc, StablePoolRpcApiServer};
 use bifrost_stable_pool_rpc_runtime_api::StablePoolRuntimeApi;
 use bifrost_ve_minting_rpc::{VeMintingRpc, VeMintingRpcApiServer};
 use bifrost_ve_minting_rpc_runtime_api::VeMintingRuntimeApi;
+use bifrost_vtoken_minting_rpc::{VtokenMintingRpc, VtokenMintingRpcApiServer};
+use bifrost_vtoken_minting_rpc_runtime_api::VtokenMintingRuntimeApi;
 use lend_market_rpc::{LendMarket, LendMarketApiServer};
 use lend_market_rpc_runtime_api::LendMarketApi;
 use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};
@@ -89,6 +91,7 @@ where
 	C::Api: SalpRuntimeApi<Block, ParaId, AccountId>,
 	C::Api: StablePoolRuntimeApi<Block>,
 	C::Api: LendMarketApi<Block, AccountId, Balance>,
+	C::Api: VtokenMintingRuntimeApi<Block, CurrencyId>,
 	C::Api: ZenlinkProtocolRuntimeApi<Block, AccountId, AssetId>,
 	C::Api:
 		zenlink_stable_amm_runtime_api::StableAmmApi<Block, CurrencyId, Balance, AccountId, PoolId>,
@@ -107,7 +110,8 @@ where
 	module.merge(ZenlinkProtocol::new(client.clone()).into_rpc())?;
 	module.merge(StableAmm::new(client.clone()).into_rpc())?;
 	module.merge(StablePoolRpc::new(client.clone()).into_rpc())?;
-	module.merge(LendMarket::new(client).into_rpc())?;
+	module.merge(LendMarket::new(client.clone()).into_rpc())?;
+	module.merge(VtokenMintingRpc::new(client).into_rpc())?;
 
 	Ok(module)
 }
@@ -131,6 +135,7 @@ where
 	C::Api: SalpRuntimeApi<Block, ParaId, AccountId>,
 	C::Api: VeMintingRuntimeApi<Block, AccountId>,
 	C::Api: LendMarketApi<Block, AccountId, Balance>,
+	C::Api: VtokenMintingRuntimeApi<Block, CurrencyId>,
 	C::Api: ZenlinkProtocolRuntimeApi<Block, AccountId, AssetId>,
 	C::Api: StablePoolRuntimeApi<Block>,
 	C::Api: BlockBuilder<Block>,
@@ -148,7 +153,8 @@ where
 	module.merge(VeMintingRpc::new(client.clone()).into_rpc())?;
 	module.merge(ZenlinkProtocol::new(client.clone()).into_rpc())?;
 	module.merge(StablePoolRpc::new(client.clone()).into_rpc())?;
-	module.merge(LendMarket::new(client).into_rpc())?;
+	module.merge(LendMarket::new(client.clone()).into_rpc())?;
+	module.merge(VtokenMintingRpc::new(client).into_rpc())?;
 
 	Ok(module)
 }

pallets/vtoken-minting/rpc/Cargo.toml

@@ -14,4 +14,4 @@ sp-blockchain = { workspace = true }
 sp-core = { workspace = true }
 sp-rpc = { workspace = true }
 bifrost-primitives = { workspace = true }
-bifrost-ve-minting-rpc-runtime-api = { workspace = true }
+bifrost-vtoken-minting-rpc-runtime-api = { workspace = true }

pallets/vtoken-minting/rpc/src/lib.rs

@@ -18,23 +18,18 @@
 
 use std::{marker::PhantomData, sync::Arc};
 
-use bifrost_primitives::Balance;
-pub use bifrost_vtoken_minting_rpc_runtime_api::{self as runtime_api, VtokenMintingRuntimeApi};
+pub use bifrost_vtoken_minting_rpc_runtime_api::VtokenMintingRuntimeApi;
 use jsonrpsee::{
 	core::{async_trait, RpcResult},
 	proc_macros::rpc,
-	types::error::{CallError, ErrorCode, ErrorObject},
+	types::error::{ErrorCode, ErrorObject},
 };
 use parity_scale_codec::Codec;
 use sp_api::ProvideRuntimeApi;
 use sp_blockchain::HeaderBackend;
 use sp_core::U256;
 use sp_rpc::number::NumberOrHex;
-use sp_runtime::{
-	generic::BlockId,
-	traits::{Block as BlockT, BlockIdTo},
-	SaturatedConversion,
-};
+use sp_runtime::traits::Block as BlockT;
 
 #[rpc(client, server)]
 pub trait VtokenMintingRpcApi<CurrencyId, BlockHash> {
@@ -53,43 +48,41 @@ pub struct VtokenMintingRpc<C, Block> {
 	_marker: PhantomData<Block>,
 }
 
-impl<C, Block> VtokenMintingRpc<C, Block>
-where
-	Block: BlockT,
-	C: BlockIdTo<Block>,
-{
+impl<C, Block> VtokenMintingRpc<C, Block> {
 	pub fn new(client: Arc<C>) -> Self {
 		Self { client, _marker: PhantomData }
 	}
 }
 
 #[async_trait]
-impl<C, Block, CurrencyId> VtokenMintingRpcApiServer<<Block as BlockT>::Hash, AccountId>
+impl<C, Block, CurrencyId> VtokenMintingRpcApiServer<CurrencyId, <Block as BlockT>::Hash>
 	for VtokenMintingRpc<C, Block>
 where
 	Block: BlockT,
-	C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block> + BlockIdTo<Block>,
-	C::Api: VeMintingRuntimeApi<Block, AccountId>,
+	C: Send + Sync + 'static + ProvideRuntimeApi<Block> + HeaderBackend<Block>,
+	C::Api: VtokenMintingRuntimeApi<Block, CurrencyId>,
 	CurrencyId: Codec,
 {
 	fn get_exchange_rate(
 		&self,
 		token_id: Option<CurrencyId>,
 		at: Option<<Block as BlockT>::Hash>,
 	) -> RpcResult<Vec<(CurrencyId, NumberOrHex)>> {
-		let lm_rpc_api = self.client.runtime_api();
+		let api = self.client.runtime_api();
 		let at = at.unwrap_or_else(|| self.client.info().best_hash);
 
-		let rs: Result<U256, _> = lm_rpc_api.get_exchange_rate(at, token_id, max_epoch);
+		let rs: Result<Vec<(CurrencyId, U256)>, _> = api.get_exchange_rate(at, token_id);
 
 		match rs {
-			Ok(epoch) => Ok(NumberOrHex::Hex(epoch.into())),
-			Err(e) => Err(CallError::Custom(ErrorObject::owned(
+			Ok(data) => Ok(data
+				.into_iter()
+				.map(|(token, rate)| (token, NumberOrHex::Hex(rate.into())))
+				.collect()),
+			Err(e) => Err(ErrorObject::owned(
 				ErrorCode::InternalError.code(),
-				"Failed to get exchange rate.",
+				"Failed to get find_block_epoch.",
 				Some(format!("{:?}", e)),
-			))),
+			)),
 		}
-		.map_err(|e| jsonrpsee::core::Error::Call(e))
 	}
 }

pallets/vtoken-minting/src/lib.rs

@@ -1934,7 +1934,7 @@ pub mod pallet {
 
 			match token_id {
 				Some(token_id) => {
-					let vtoken_amount = Self::get_vtoken_amount(token_id, 1u128)?;
+					let vtoken_amount = Self::get_vtoken_amount(token_id, 1000u128)?;
 					result.push((token_id, vtoken_amount));
 				},
 				None =>