redesign remote price oracle

Author: uint

Cargo.lock

@@ -20,8 +20,9 @@ mt = ["library", "sylvia/mt"]
 
 [dependencies]
 mesh-apis        = { workspace = true }
+mesh-bindings    = { workspace = true }
 
-sylvia = { workspace = true }
+sylvia           = { workspace = true }
 cosmwasm-schema  = { workspace = true }
 cosmwasm-std     = { workspace = true }
 cosmwasm-storage = { workspace = true }

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

@@ -1,19 +1,28 @@
-use cosmwasm_std::{Decimal, Response};
+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::RemotePriceFeedSudoMsg;
 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 const EPOCH_IN_SECS: u64 = 120;
+
 pub struct RemotePriceFeedContract {
-    pub native_per_foreign: Item<'static, Decimal>,
+    pub channel: Item<'static, IbcChannel>,
+    pub trading_pair: Item<'static, TradingPair>,
+    pub price_info: Item<'static, PriceInfo>,
+    pub last_epoch: Item<'static, Timestamp>,
 }
 
 #[cfg_attr(not(feature = "library"), sylvia::entry_points)]
@@ -23,17 +32,31 @@ pub struct RemotePriceFeedContract {
 impl RemotePriceFeedContract {
     pub const fn new() -> Self {
         Self {
-            native_per_foreign: Item::new("price"),
+            channel: Item::new("channel"),
+            trading_pair: Item::new("tpair"),
+            price_info: Item::new("price"),
+            last_epoch: Item::new("last_epoch"),
         }
     }
 
     /// Sets up the contract with an initial price.
     /// If the owner is not set in the message, it defaults to info.sender.
     #[msg(instantiate)]
-    pub fn instantiate(&self, ctx: InstantiateCtx) -> Result<Response, ContractError> {
+    pub fn instantiate(
+        &self,
+        ctx: InstantiateCtx,
+        trading_pair: TradingPair,
+        auth_endpoint: AuthorizedEndpoint,
+    ) -> 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)?;
+
+        AUTH_ENDPOINT.save(ctx.deps.storage, &auth_endpoint)?;
+
         Ok(Response::new())
     }
 }
@@ -47,11 +70,48 @@ impl PriceFeedApi for RemotePriceFeedContract {
     /// are needed to buy one foreign token.
     #[msg(query)]
     fn price(&self, ctx: QueryCtx) -> Result<PriceResponse, Self::Error> {
-        let native_per_foreign = self.native_per_foreign.may_load(ctx.deps.storage)?;
-        native_per_foreign
-            .map(|price| PriceResponse {
-                native_per_foreign: price,
+        let price_info = self.price_info.may_load(ctx.deps.storage)?;
+        price_info
+            .map(|info| PriceResponse {
+                native_per_foreign: info.native_per_foreign,
             })
             .ok_or(ContractError::NoPriceData)
     }
 }
+
+#[cfg_attr(not(feature = "library"), entry_point)]
+pub fn sudo(
+    deps: DepsMut,
+    env: Env,
+    msg: RemotePriceFeedSudoMsg,
+) -> Result<Response, ContractError> {
+    match msg {
+        RemotePriceFeedSudoMsg::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 secs_since_last_epoch = env.block.time.seconds() - last_epoch.seconds();
+            if secs_since_last_epoch >= EPOCH_IN_SECS {
+                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/contract.rs

@@ -20,14 +20,17 @@ pub enum ContractError {
     #[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 accept ack packets")]
-    IbcAckNotAccepted,
+    #[error("Contract does not receive packets except for acknowledgements")]
+    IbcReceiveNotAccepted,
 
     #[error("The oracle hasn't received any price data")]
     NoPriceData,

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

@@ -2,16 +2,20 @@
 use cosmwasm_std::entry_point;
 
 use cosmwasm_std::{
-    from_slice, DepsMut, Env, Ibc3ChannelOpenResponse, IbcBasicResponse, IbcChannel,
-    IbcChannelCloseMsg, IbcChannelConnectMsg, IbcChannelOpenMsg, IbcChannelOpenResponse,
+    from_slice, to_binary, DepsMut, Env, Ibc3ChannelOpenResponse, IbcBasicResponse, IbcChannel,
+    IbcChannelCloseMsg, IbcChannelConnectMsg, IbcChannelOpenMsg, IbcChannelOpenResponse, IbcMsg,
     IbcPacketAckMsg, IbcPacketReceiveMsg, IbcPacketTimeoutMsg, IbcReceiveResponse, IbcTimeout,
+    Timestamp,
 };
 use cw_storage_plus::Item;
-use mesh_apis::ibc::{validate_channel_order, PriceFeedProviderPacket, ProtocolVersion};
+use mesh_apis::ibc::{
+    validate_channel_order, PriceFeedProviderAck, ProtocolVersion, RemotePriceFeedPacket,
+};
 
 use crate::contract::RemotePriceFeedContract;
 use crate::error::ContractError;
 use crate::msg::AuthorizedEndpoint;
+use crate::state::PriceInfo;
 
 /// This is the maximum version of the Mesh Security protocol that we support
 const SUPPORTED_IBC_PROTOCOL_VERSION: &str = "0.11.0";
@@ -20,16 +24,11 @@ const MIN_IBC_PROTOCOL_VERSION: &str = "0.11.0";
 
 // IBC specific state
 pub const AUTH_ENDPOINT: Item<AuthorizedEndpoint> = Item::new("auth_endpoint");
-pub const IBC_CHANNEL: Item<IbcChannel> = Item::new("ibc_channel");
 
-// If we don't hear anything within 10 minutes, let's abort, for better UX
-// This is long enough to allow some clock drift between chains
-const DEFAULT_TIMEOUT: u64 = 10 * 60;
+const TIMEOUT: u64 = 10 * 60;
 
-pub fn packet_timeout(env: &Env) -> IbcTimeout {
-    // No idea about their block time, but 24 hours ahead of our view of the clock
-    // should be decently in the future.
-    let timeout = env.block.time.plus_seconds(DEFAULT_TIMEOUT);
+pub fn packet_timeout(now: &Timestamp) -> IbcTimeout {
+    let timeout = now.plus_seconds(TIMEOUT);
     IbcTimeout::with_timestamp(timeout)
 }
 
@@ -41,7 +40,8 @@ pub fn ibc_channel_open(
     msg: IbcChannelOpenMsg,
 ) -> Result<IbcChannelOpenResponse, ContractError> {
     // ensure we have no channel yet
-    if IBC_CHANNEL.may_load(deps.storage)?.is_some() {
+    let contract = RemotePriceFeedContract::new();
+    if contract.channel.may_load(deps.storage)?.is_some() {
         return Err(ContractError::IbcChannelAlreadyOpen);
     }
     // ensure we are called with OpenInit
@@ -83,8 +83,10 @@ pub fn ibc_channel_connect(
     _env: Env,
     msg: IbcChannelConnectMsg,
 ) -> Result<IbcBasicResponse, ContractError> {
+    let contract = RemotePriceFeedContract::new();
+
     // ensure we have no channel yet
-    if IBC_CHANNEL.may_load(deps.storage)?.is_some() {
+    if contract.channel.may_load(deps.storage)?.is_some() {
         return Err(ContractError::IbcChannelAlreadyOpen);
     }
     // ensure we are called with OpenConfirm
@@ -94,7 +96,8 @@ pub fn ibc_channel_connect(
     };
 
     // Version negotiation over, we can only store the channel
-    IBC_CHANNEL.save(deps.storage, &channel)?;
+    let contract = RemotePriceFeedContract::new();
+    contract.channel.save(deps.storage, &channel)?;
 
     Ok(IbcBasicResponse::default())
 }
@@ -110,29 +113,30 @@ pub fn ibc_channel_close(
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn ibc_packet_receive(
-    deps: DepsMut,
+    _deps: DepsMut,
     _env: Env,
-    msg: IbcPacketReceiveMsg,
+    _msg: IbcPacketReceiveMsg,
 ) -> Result<IbcReceiveResponse, ContractError> {
-    let packet: PriceFeedProviderPacket = from_slice(&msg.packet.data)?;
-    let resp = match packet {
-        PriceFeedProviderPacket::Update { twap } => {
-            let contract = RemotePriceFeedContract::new();
-            contract.native_per_foreign.save(deps.storage, &twap)?;
-            IbcReceiveResponse::new()
-        }
-    };
-
-    Ok(resp)
+    Err(ContractError::IbcReceiveNotAccepted)
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn ibc_packet_ack(
-    _deps: DepsMut,
+    deps: DepsMut,
     _env: Env,
-    _msg: IbcPacketAckMsg,
+    msg: IbcPacketAckMsg,
 ) -> Result<IbcBasicResponse, ContractError> {
-    Err(ContractError::IbcAckNotAccepted)
+    let ack: PriceFeedProviderAck = from_slice(&msg.acknowledgement.data)?;
+    let PriceFeedProviderAck::Update { twap } = ack;
+    let contract = RemotePriceFeedContract::new();
+    contract.price_info.save(
+        deps.storage,
+        &PriceInfo {
+            native_per_foreign: twap,
+        },
+    )?;
+
+    Ok(IbcBasicResponse::new())
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
@@ -141,5 +145,17 @@ pub fn ibc_packet_timeout(
     _env: Env,
     _msg: IbcPacketTimeoutMsg,
 ) -> Result<IbcBasicResponse, ContractError> {
-    Err(ContractError::IbcAckNotAccepted)
+    Err(ContractError::IbcReceiveNotAccepted)
+}
+
+pub(crate) fn make_ibc_packet(
+    now: &Timestamp,
+    channel: IbcChannel,
+    packet: RemotePriceFeedPacket,
+) -> Result<IbcMsg, ContractError> {
+    Ok(IbcMsg::SendPacket {
+        channel_id: channel.endpoint.channel_id,
+        data: to_binary(&packet)?,
+        timeout: packet_timeout(now),
+    })
 }

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

@@ -1 +1,14 @@
+use cosmwasm_schema::cw_serde;
+use cosmwasm_std::Decimal;
 
+#[cw_serde]
+pub struct TradingPair {
+    pub pool_id: u64,
+    pub base_asset: String,
+    pub quote_asset: String,
+}
+
+#[cw_serde]
+pub struct PriceInfo {
+    pub native_per_foreign: Decimal,
+}