Osmosis price oracle

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["packages/*", "contracts/provider/*", "contracts/consumer/*"]
+members = ["packages/*", "contracts/provider/*", "contracts/consumer/*", "contracts/osmosis-price-provider"]
 resolver = "2"
 
 [workspace.package]
@@ -31,6 +31,7 @@ cosmwasm-storage = "1.3.3"
 cw-storage-plus  = "1.1.0"
 cw-utils         = "1.0.1"
 cw2              = "1.0.1"
+osmosis-std      = "0.20.1"
 schemars         = "0.8.11"
 serde            = { version = "1.0.152", default-features = false, features = ["derive"] }
 thiserror        = "1.0.38"

contracts/consumer/remote-price-feed/.cargo/config

@@ -0,0 +1,4 @@
+[alias]
+wasm = "build --release --lib --target wasm32-unknown-unknown"
+unit-test = "test --lib"
+schema = "run --bin schema"

contracts/consumer/remote-price-feed/Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "mesh-remote-price-feed"
+description = "Returns exchange rates of assets synchronized with an Osmosis price provider"
+version = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+repository = { workspace = true }
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# for more explicit tests, cargo test --features=backtraces
+backtraces = ["cosmwasm-std/backtraces"]
+# use library feature to disable all instantiate/execute/query exports
+library = []
+# enables generation of mt utilities
+mt = ["library", "sylvia/mt"]
+
+[dependencies]
+mesh-apis        = { workspace = true }
+mesh-bindings    = { workspace = true }
+
+sylvia           = { workspace = true }
+cosmwasm-schema  = { workspace = true }
+cosmwasm-std     = { workspace = true }
+cosmwasm-storage = { workspace = true }
+cw-storage-plus  = { workspace = true }
+cw2              = { workspace = true }
+cw-utils         = { workspace = true }
+
+schemars         = { workspace = true }
+serde            = { workspace = true }
+thiserror        = { workspace = true }
+
+[dev-dependencies]
+cw-multi-test = { workspace = true }
+test-case     = { workspace = true }
+derivative    = { workspace = true }
+anyhow        = { workspace = true }
+
+[[bin]]
+name = "schema"
+doc  = false

contracts/consumer/remote-price-feed/README.md

@@ -0,0 +1,12 @@
+# Remote Price Feed
+
+This implements the [price feed API](../../../packages/apis/src/price_feed_api.rs).
+
+This contract provides exchange rate data by contacting an [Osmosis Price Provider](../osmosis-price-provider).
+
+A single trading pair has to be configured on instantiation, along with the IBC endpoint. In case multiple trading pairs need to be synced, multiple contracts must be deployed.
+
+For this contract to work correctly:
+
+- An IBC connection to [Osmosis Price Provider](../osmosis-price-provider) must be opened.
+- A`SudoMsg::EndBlock {}` must be sent to the contract regularly. This will allow the contract to request regular updates of locally stored data.

contracts/consumer/remote-price-feed/src/bin/schema.rs

@@ -0,0 +1,12 @@
+use cosmwasm_schema::write_api;
+
+use mesh_remote_price_feed::contract::{ContractExecMsg, ContractQueryMsg, InstantiateMsg};
+
+#[cfg(not(tarpaulin_include))]
+fn main() {
+    write_api! {
+        instantiate: InstantiateMsg,
+        execute: ContractExecMsg,
+        query: ContractQueryMsg,
+    }
+}

contracts/consumer/remote-price-feed/src/contract.rs

@@ -0,0 +1,126 @@
+use cosmwasm_std::{entry_point, DepsMut, Env, IbcChannel, Response, Timestamp};
+use cw2::set_contract_version;
+use cw_storage_plus::Item;
+use cw_utils::nonpayable;
+use mesh_bindings::SudoMsg;
+use sylvia::types::{InstantiateCtx, QueryCtx};
+use sylvia::{contract, schemars};
+
+use mesh_apis::price_feed_api::{self, PriceFeedApi, PriceResponse};
+
+use crate::error::ContractError;
+use crate::ibc::{make_ibc_packet, AUTH_ENDPOINT};
+use crate::msg::AuthorizedEndpoint;
+use crate::state::{PriceInfo, TradingPair};
+
+pub const CONTRACT_NAME: &str = env!("CARGO_PKG_NAME");
+pub const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+pub struct RemotePriceFeedContract {
+    pub channel: Item<'static, IbcChannel>,
+    pub trading_pair: Item<'static, TradingPair>,
+    pub price_info: Item<'static, PriceInfo>,
+    pub last_epoch: Item<'static, Timestamp>,
+    pub epoch_in_secs: Item<'static, u64>,
+    pub price_info_ttl_in_secs: Item<'static, u64>,
+}
+
+#[cfg_attr(not(feature = "library"), sylvia::entry_points)]
+#[contract]
+#[error(ContractError)]
+#[messages(price_feed_api as PriceFeedApi)]
+impl RemotePriceFeedContract {
+    pub const fn new() -> Self {
+        Self {
+            channel: Item::new("channel"),
+            trading_pair: Item::new("tpair"),
+            price_info: Item::new("price"),
+            last_epoch: Item::new("last_epoch"),
+            epoch_in_secs: Item::new("epoch"),
+            price_info_ttl_in_secs: Item::new("price_ttl"),
+        }
+    }
+
+    #[msg(instantiate)]
+    pub fn instantiate(
+        &self,
+        ctx: InstantiateCtx,
+        trading_pair: TradingPair,
+        auth_endpoint: AuthorizedEndpoint,
+        epoch_in_secs: u64,
+        price_info_ttl_in_secs: u64,
+    ) -> Result<Response, ContractError> {
+        nonpayable(&ctx.info)?;
+
+        set_contract_version(ctx.deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
+        self.last_epoch
+            .save(ctx.deps.storage, &Timestamp::from_seconds(0))?;
+        self.trading_pair.save(ctx.deps.storage, &trading_pair)?;
+        self.epoch_in_secs.save(ctx.deps.storage, &epoch_in_secs)?;
+        self.price_info_ttl_in_secs
+            .save(ctx.deps.storage, &price_info_ttl_in_secs)?;
+
+        AUTH_ENDPOINT.save(ctx.deps.storage, &auth_endpoint)?;
+
+        Ok(Response::new())
+    }
+}
+
+#[contract]
+#[messages(price_feed_api as PriceFeedApi)]
+impl PriceFeedApi for RemotePriceFeedContract {
+    type Error = ContractError;
+
+    /// Return the price of the foreign token. That is, how many native tokens
+    /// are needed to buy one foreign token.
+    #[msg(query)]
+    fn price(&self, ctx: QueryCtx) -> Result<PriceResponse, Self::Error> {
+        let price_info_ttl = self.price_info_ttl_in_secs.load(ctx.deps.storage)?;
+        let price_info = self
+            .price_info
+            .may_load(ctx.deps.storage)?
+            .ok_or(ContractError::NoPriceData)?;
+
+        if ctx.env.block.time.minus_seconds(price_info_ttl) < price_info.time {
+            Ok(PriceResponse {
+                native_per_foreign: price_info.native_per_foreign,
+            })
+        } else {
+            Err(ContractError::OutdatedPriceData)
+        }
+    }
+}
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn sudo(deps: DepsMut, env: Env, msg: SudoMsg) -> Result<Response, ContractError> {
+    match msg {
+        SudoMsg::EndBlock {} => {
+            let contract = RemotePriceFeedContract::new();
+            let TradingPair {
+                pool_id,
+                base_asset,
+                quote_asset,
+            } = contract.trading_pair.load(deps.storage)?;
+            let channel = contract
+                .channel
+                .may_load(deps.storage)?
+                .ok_or(ContractError::IbcChannelNotOpen)?;
+
+            let last_epoch = contract.last_epoch.load(deps.storage)?;
+            let epoch_duration = contract.epoch_in_secs.load(deps.storage)?;
+            let secs_since_last_epoch = env.block.time.seconds() - last_epoch.seconds();
+            if secs_since_last_epoch >= epoch_duration {
+                let packet = mesh_apis::ibc::RemotePriceFeedPacket::QueryTwap {
+                    pool_id,
+                    base_asset,
+                    quote_asset,
+                };
+                let msg = make_ibc_packet(&env.block.time, channel, packet)?;
+
+                Ok(Response::new().add_message(msg))
+            } else {
+                Ok(Response::new())
+            }
+        }
+    }
+}

contracts/consumer/remote-price-feed/src/error.rs

@@ -0,0 +1,40 @@
+use cosmwasm_std::StdError;
+use cw_utils::PaymentError;
+use mesh_apis::ibc::VersionError;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ContractError {
+    #[error("{0}")]
+    Std(#[from] StdError),
+
+    #[error("{0}")]
+    Payment(#[from] PaymentError),
+
+    #[error("{0}")]
+    IbcVersion(#[from] VersionError),
+
+    #[error("Unauthorized")]
+    Unauthorized,
+
+    #[error("Invalid authorized endpoint: {0}")]
+    InvalidEndpoint(String),
+
+    #[error("Contract doesn't have an open IBC channel")]
+    IbcChannelNotOpen,
+
+    #[error("Contract already has an open IBC channel")]
+    IbcChannelAlreadyOpen,
+
+    #[error("You must start the channel handshake on the other side, it doesn't support OpenInit")]
+    IbcOpenInitDisallowed,
+
+    #[error("Contract does not receive packets except for acknowledgements")]
+    IbcReceiveNotAccepted,
+
+    #[error("The oracle hasn't received any price data")]
+    NoPriceData,
+
+    #[error("The oracle's price data is outdated")]
+    OutdatedPriceData,
+}