Release query

platform/contracts/admin/src/endpoints.rs

@@ -224,6 +224,9 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> ContractResult<Binary>
             .and_then(|ref protocol| {
                 cosmwasm_std::to_json_binary::<ProtocolQueryResponse>(protocol).map_err(Into::into)
             }),
+        QueryMsg::PlatformPackageRelease {} => {
+            cosmwasm_std::to_json_binary(&CURRENT_RELEASE).map_err(Into::into)
+        }
     }
 }
 

platform/contracts/admin/src/msg.rs

@@ -93,10 +93,15 @@ where
     Uint64: Into<CodeId>,
     CodeId: Into<Uint64>,
 {
-    InstantiateAddress { code_id: Uint64, protocol: String },
+    InstantiateAddress {
+        code_id: Uint64,
+        protocol: String,
+    },
     Protocols {},
     Platform {},
     Protocol(String),
+    /// Implementation of [versioning::query::PlatformPackage::Release]
+    PlatformPackageRelease {},
 }
 
 pub type ProtocolsQueryResponse = Vec<String>;

platform/contracts/timealarms/src/contract.rs

@@ -83,6 +83,9 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> ContractResult<Binary>
         QueryMsg::AlarmsStatus {} => Ok(to_json_binary(
             &TimeAlarms::new(deps.storage).try_any_alarm(env.block.time)?,
         )?),
+        QueryMsg::PlatformPackageRelease {} => {
+            cosmwasm_std::to_json_binary(&CURRENT_RELEASE).map_err(Into::into)
+        }
     }
     .inspect_err(platform_error::log(deps.api))
 }

platform/contracts/timealarms/src/msg.rs

@@ -42,6 +42,8 @@ pub enum SudoMsg {}
 pub enum QueryMsg {
     ContractVersion {},
     AlarmsStatus {},
+    /// Implementation of [versioning::query::PlatformPackage::Release]
+    PlatformPackageRelease {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Copy, Eq, PartialEq, JsonSchema)]

platform/contracts/treasury/src/contract.rs

@@ -107,6 +107,9 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> ContractResult<Binary>
         }
         QueryMsg::CalculateRewards {} => query_reward_apr(deps.storage, deps.querier, &env)
             .and_then(|ref apr| to_json_binary(apr).map_err(ContractError::Serialize)),
+        QueryMsg::PlatformPackageRelease {} => {
+            cosmwasm_std::to_json_binary(&CURRENT_RELEASE).map_err(Into::into)
+        }
     }
     .inspect_err(platform_error::log(deps.api))
 }

platform/contracts/treasury/src/msg.rs

@@ -41,6 +41,8 @@ pub enum SudoMsg {
 pub enum QueryMsg {
     Config {},
     CalculateRewards {},
+    /// Implementation of [versioning::query::PlatformPackage::Release]
+    PlatformPackageRelease {},
 }
 
 // We define a custom struct for each query response

platform/packages/versioning/src/lib.rs

@@ -6,8 +6,8 @@ pub use crate::{
     error::Error,
     protocol::Release as ProtocolRelease,
     release::{
-        Id as ReleaseId, PlatformPackageRelease, ProtocolPackageRelease, ProtocolPackageReleaseId,
-        UpdatablePackage,
+        query, Id as ReleaseId, PlatformPackageRelease, ProtocolPackageRelease,
+        ProtocolPackageReleaseId, UpdatablePackage,
     },
     software::{PackageRelease as SoftwarePackageRelease, VersionSegment},
 };

platform/packages/versioning/src/release/mod.rs

@@ -9,6 +9,7 @@ pub use self::id::Id;
 #[cfg(feature = "protocol_contract")]
 mod current;
 mod id;
+pub mod query;
 
 pub trait UpdatablePackage
 where
@@ -26,12 +27,15 @@ where
 }
 
 pub type PlatformPackageRelease = SoftwarePackageRelease;
+#[derive(Serialize, Deserialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub struct ProtocolPackageRelease {
     software: SoftwarePackageRelease,
     protocol: ProtocolRelease,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub struct ProtocolPackageReleaseId {
     software: Id,
     protocol: Id,

platform/packages/versioning/src/release/query.rs

@@ -0,0 +1,52 @@
+use serde::Serialize;
+use thiserror::Error;
+
+use sdk::cosmwasm_std::{Addr, QuerierWrapper, StdError};
+
+use super::{PlatformPackageRelease, ProtocolPackageRelease};
+
+/// A common versioning API of each platform package
+#[derive(Serialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
+pub enum PlatformPackage {
+    /// Query the platform package for its release.
+    ///
+    /// The result is [versioning::PlatformPackageRelease]
+    #[serde(rename = "platform_package_release")]
+    Release {},
+}
+
+/// A common versioning API of each protocol package
+#[derive(Serialize)]
+#[serde(deny_unknown_fields, rename_all = "snake_case")]
+pub enum ProtocolPackage {
+    /// Query the protocol package for its release.
+    ///
+    /// The result is [versioning::ProtocolPackageRelease]
+    #[serde(rename = "protocol_package_release")]
+    Release {},
+}
+
+#[derive(Error, Debug, PartialEq)]
+pub enum Error {
+    #[error("[Versioning][Query] {0}")]
+    Transmission(StdError),
+}
+
+pub fn platform_release(
+    contract: Addr,
+    querier: QuerierWrapper<'_>,
+) -> Result<PlatformPackageRelease, Error> {
+    querier
+        .query_wasm_smart(contract, &PlatformPackage::Release {})
+        .map_err(Error::Transmission)
+}
+
+pub fn protocol_release(
+    contract: Addr,
+    querier: QuerierWrapper<'_>,
+) -> Result<ProtocolPackageRelease, Error> {
+    querier
+        .query_wasm_smart(contract, &ProtocolPackage::Release {})
+        .map_err(Error::Transmission)
+}

protocol/contracts/lease/examples/lease_schema.rs

@@ -1,9 +1,9 @@
-use lease::api::{open::NewLeaseForm, query::StateQuery, ExecuteMsg};
+use lease::api::{open::NewLeaseForm, query::QueryMsg, ExecuteMsg};
 use sdk::cosmwasm_schema::{export_schema, schema_for};
 
 fn main() {
     let out_dir = schema::prep_out_dir().expect("The output directory should be valid");
     export_schema(&schema_for!(NewLeaseForm), &out_dir);
     export_schema(&schema_for!(ExecuteMsg), &out_dir);
-    export_schema(&schema_for!(StateQuery), &out_dir);
+    export_schema(&schema_for!(QueryMsg), &out_dir);
 }

protocol/contracts/lease/src/api/query.rs

@@ -19,12 +19,18 @@ pub use opened::ClosePolicy;
 #[derive(Deserialize, JsonSchema)]
 #[cfg_attr(any(test, feature = "testing"), derive(Clone, Debug, Serialize))]
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
-pub struct StateQuery {
+pub enum QueryMsg {
     /// Ask for estimation of the due and overdue amounts and periods in that point of time
     ///
+    /// Return a [StateResponse]
+    ///
     /// The value is meaningfull only if the lease is in Opened state.
-    #[serde(default, rename = "due_projection_secs")]
-    pub due_projection: Seconds,
+    State {
+        #[serde(default, rename = "due_projection_secs")]
+        due_projection: Seconds,
+    },
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
 }
 
 #[derive(Serialize)]

protocol/contracts/lease/src/contract/endpoins.rs

@@ -13,7 +13,7 @@ use versioning::{
 };
 
 use crate::{
-    api::{open::NewLeaseContract, query::StateQuery, ExecuteMsg, MigrateMsg},
+    api::{open::NewLeaseContract, query::QueryMsg, ExecuteMsg, MigrateMsg},
     contract::api::Contract,
     error::{ContractError, ContractResult},
 };
@@ -93,17 +93,20 @@ pub fn sudo(deps: DepsMut<'_>, env: Env, msg: SudoMsg) -> ContractResult<CwRespo
 }
 
 #[entry_point]
-pub fn query(deps: Deps<'_>, env: Env, msg: StateQuery) -> ContractResult<Binary> {
-    state::load(deps.storage)
-        .and_then(|state| {
-            state.state(
-                env.block.time,
-                Duration::from_secs(msg.due_projection),
-                deps.querier,
-            )
-        })
-        .and_then(|resp| to_json_binary(&resp).map_err(Into::into))
-        .inspect_err(platform_error::log(deps.api))
+pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> ContractResult<Binary> {
+    match msg {
+        QueryMsg::State { due_projection } => state::load(deps.storage)
+            .and_then(|state| {
+                state.state(
+                    env.block.time,
+                    Duration::from_secs(due_projection),
+                    deps.querier,
+                )
+            })
+            .and_then(|resp| to_json_binary(&resp).map_err(Into::into)),
+        QueryMsg::ProtocolPackageRelease {} => to_json_binary(&CURRENT_RELEASE).map_err(Into::into),
+    }
+    .inspect_err(platform_error::log(deps.api))
 }
 
 fn process_lease<ProcFn>(

protocol/contracts/leaser/src/contract.rs

@@ -179,6 +179,7 @@ pub fn sudo(deps: DepsMut<'_>, _env: Env, msg: SudoMsg) -> ContractResult<Respon
 pub fn query(deps: Deps<'_>, _env: Env, msg: QueryMsg) -> ContractResult<Binary> {
     match msg {
         QueryMsg::Config {} => to_json_binary(&Leaser::new(deps).config()?),
+        QueryMsg::ProtocolPackageRelease {} => to_json_binary(&CURRENT_RELEASE),
         QueryMsg::Quote {
             downpayment,
             lease_asset,

protocol/contracts/leaser/src/msg.rs

@@ -126,6 +126,8 @@ pub enum ForceClose {
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub enum QueryMsg {
     Config {},
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
     Quote {
         downpayment: DownpaymentCoin,
         lease_asset: CurrencyDTO<LeaseCurrencies>,

protocol/contracts/lpp/src/contract/mod.rs

@@ -156,6 +156,7 @@ pub fn sudo(deps: DepsMut<'_>, _env: Env, msg: SudoMsg) -> Result<CwResponse> {
 pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg<LpnCurrencies>) -> Result<Binary> {
     match msg {
         QueryMsg::Config() => Config::load(deps.storage).and_then(|ref resp| to_json_binary(resp)),
+        QueryMsg::ProtocolPackageRelease {} => to_json_binary(&CURRENT_RELEASE),
         QueryMsg::Lpn() => to_json_binary(LpnCurrency::definition().dto()),
         QueryMsg::Balance { address } => {
             lender::query_balance(deps.storage, address).and_then(|ref resp| to_json_binary(resp))

protocol/contracts/lpp/src/msg.rs

@@ -94,6 +94,8 @@ where
     Lpns: Group,
 {
     Config(),
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
     /// Report the Lpn currency as [CurrencyDTO<Lpns>]
     Lpn(),
     Quote {

protocol/contracts/oracle/src/api/contract.rs

@@ -87,6 +87,9 @@ where
     // Returns contract's semantic version as a package, which is set in `Cargo.toml`.
     ContractVersion {},
 
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
+
     // returns the contract configuration
     Config {},
 

protocol/contracts/oracle/src/contract/mod.rs

@@ -81,6 +81,7 @@ pub fn migrate(
 pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg<PriceCurrencies>) -> ContractResult<Binary> {
     match msg {
         QueryMsg::ContractVersion {} => to_json_binary(CURRENT_VERSION),
+        QueryMsg::ProtocolPackageRelease {} => to_json_binary(&CURRENT_RELEASE),
         QueryMsg::Config {} => to_json_binary(&query_config(deps.storage)?),
         QueryMsg::Feeders {} => Feeders::get(deps.storage)
             .map_err(ContractError::LoadFeeders)

protocol/contracts/profit/src/contract.rs

@@ -222,6 +222,7 @@ pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> ContractResult<Binary>
             env.block.time,
             deps.querier,
         )?),
+        QueryMsg::ProtocolPackageRelease {} => to_json_binary(&CURRENT_RELEASE),
     }
     .map_err(Into::into)
 }

protocol/contracts/profit/src/msg.rs

@@ -51,6 +51,8 @@ pub enum ExecuteMsg {
 #[serde(deny_unknown_fields, rename_all = "snake_case")]
 pub enum QueryMsg {
     Config {},
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
 }
 
 // We define a custom struct for each query response

protocol/contracts/reserve/src/api.rs

@@ -49,6 +49,8 @@ pub enum QueryMsg {
     ReserveLpn(), // the name contains the contract name to help distinguish from simmilar queries to other contracts
     /// Return a [ConfigResponse]
     Config(),
+    /// Implementation of [versioning::query::ProtocolPackage::Release]
+    ProtocolPackageRelease {},
 }
 
 #[derive(Serialize, Deserialize, Clone, Eq, PartialEq, JsonSchema)]

protocol/contracts/reserve/src/contract.rs

@@ -110,15 +110,17 @@ pub fn execute(
 #[entry_point]
 pub fn query(deps: Deps<'_>, _env: Env, msg: QueryMsg) -> Result<Binary> {
     match msg {
-        QueryMsg::Config() => Config::load(deps.storage)
-            .map(ConfigResponse::from)
-            .and_then(|config| cosmwasm_std::to_json_binary(&config).map_err(Into::into)),
         QueryMsg::ReserveLpn() => cosmwasm_std::to_json_binary(
             &currency::to_string::<LpnCurrency>(LpnCurrency::definition()),
         )
         .map_err(Into::into),
+        QueryMsg::Config() => Config::load(deps.storage)
+            .map(ConfigResponse::from)
+            .and_then(|config| cosmwasm_std::to_json_binary(&config).map_err(Into::into)),
+        QueryMsg::ProtocolPackageRelease {} => {
+            cosmwasm_std::to_json_binary(&CURRENT_RELEASE).map_err(Into::into)
+        }
     }
-    .map_err(Into::into)
     .inspect_err(platform_error::log(deps.api))
 }
 

scripts/check/lint.sh

@@ -34,6 +34,7 @@ append_lint_flags() {
     --deny "rust-2021-compatibility" \
     --deny "rust-2024-compatibility" \
     --allow "impl-trait-overcaptures" \
+    --forbid "unfulfilled_lint_expectations" \
     --deny "unused" \
     --deny "warnings"
 }

tests/src/common/lease.rs

@@ -12,7 +12,7 @@ use lease::{
             ConnectionParams, Ics20Channel, LoanForm, NewLeaseContract, NewLeaseForm,
             PositionSpecDTO,
         },
-        query::{StateQuery, StateResponse},
+        query::{QueryMsg, StateResponse},
     },
     contract::{execute, instantiate, query, reply, sudo},
 };
@@ -351,7 +351,7 @@ pub(crate) fn fetch_state(app: &App, lease: Addr) -> StateResponse {
     app.query()
         .query_wasm_smart(
             lease,
-            &StateQuery {
+            &QueryMsg::State {
                 due_projection: Seconds::default(),
             },
         )