External stacking locks

Cargo.toml

@@ -23,7 +23,7 @@ mesh-converter    = { path = "./contracts/consumer/converter" }
 mesh-simple-price-feed    = { path = "./contracts/consumer/simple-price-feed" }
 mesh-virtual-staking    = { path = "./contracts/consumer/virtual-staking" }
 
-sylvia           = "0.4.2"
+sylvia           = "0.5.0"
 cosmwasm-schema  = "1.2"
 cosmwasm-std     = { version = "1.2", features = ["ibc3", "cosmwasm_1_2"] }
 cosmwasm-storage = "1.2"

contracts/provider/external-staking/Cargo.toml

@@ -39,6 +39,7 @@ anyhow        = { workspace = true }
 mesh-vault = { workspace = true, features = ["mt"] }
 mesh-native-staking-proxy = { workspace = true, features = ["mt"] }
 mesh-native-staking = { workspace = true, features = ["mt"] }
+mesh-sync = { workspace = true }
 
 [[bin]]
 name = "schema"

contracts/provider/external-staking/src/contract.rs

@@ -391,6 +391,7 @@ pub mod cross_staking {
             ctx: ExecCtx,
             owner: String,
             amount: Coin,
+            tx_id: u64,
             msg: Binary,
         ) -> Result<Response, Self::Error> {
             let config = self.config.load(ctx.deps.storage)?;
@@ -434,7 +435,8 @@ pub mod cross_staking {
             let resp = Response::new()
                 .add_attribute("action", "receive_virtual_stake")
                 .add_attribute("owner", owner)
-                .add_attribute("amount", amount.amount.to_string());
+                .add_attribute("amount", amount.amount.to_string())
+                .add_attribute("tx_id", tx_id.to_string());
 
             Ok(resp)
         }

contracts/provider/external-staking/src/multitest.rs

@@ -1,10 +1,15 @@
+use anyhow::Result as AnyResult;
+
 use cosmwasm_std::{coin, coins, to_binary, Addr, Decimal};
 use mesh_native_staking::contract::multitest_utils::CodeId as NativeStakingCodeId;
 use mesh_native_staking::contract::InstantiateMsg as NativeStakingInstantiateMsg;
 use mesh_native_staking_proxy::contract::multitest_utils::CodeId as NativeStakingProxyCodeId;
 use mesh_vault::contract::multitest_utils::{CodeId as VaultCodeId, VaultContractProxy};
+use mesh_vault::contract::test_utils::VaultApi;
 use mesh_vault::msg::StakingInitInfo;
 
+use mesh_sync::Tx;
+
 use cw_multi_test::App as MtApp;
 use sylvia::multitest::App;
 
@@ -13,8 +18,6 @@ use crate::contract::multitest_utils::{CodeId, ExternalStakingContractProxy};
 use crate::error::ContractError;
 use crate::msg::{ReceiveVirtualStake, StakeInfo};
 
-use anyhow::Result as AnyResult;
-
 const OSMO: &str = "osmo";
 const STAR: &str = "star";
 
@@ -127,6 +130,14 @@ fn staking() {
         .call(users[0])
         .unwrap();
 
+    let last_tx = get_last_pending_tx_id(&vault).unwrap();
+    // Hardcoded commit_tx call (lack of IBC support yet)
+    vault
+        .vault_api_proxy()
+        .commit_tx(last_tx)
+        .call(contract.contract_addr.as_str())
+        .unwrap();
+
     vault
         .stake_remote(
             contract.contract_addr.to_string(),
@@ -139,6 +150,12 @@ fn staking() {
         .call(users[0])
         .unwrap();
 
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
+
     vault
         .stake_remote(
             contract.contract_addr.to_string(),
@@ -151,6 +168,12 @@ fn staking() {
         .call(users[0])
         .unwrap();
 
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
+
     vault
         .stake_remote(
             contract.contract_addr.to_string(),
@@ -163,6 +186,12 @@ fn staking() {
         .call(users[1])
         .unwrap();
 
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
+
     vault
         .stake_remote(
             contract.contract_addr.to_string(),
@@ -174,6 +203,11 @@ fn staking() {
         )
         .call(users[1])
         .unwrap();
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     // All tokens should be only on the vault contract
     assert_eq!(app.app().wrap().query_all_balances(users[0]).unwrap(), []);
@@ -250,6 +284,14 @@ fn staking() {
     );
 }
 
+#[track_caller]
+fn get_last_pending_tx_id(vault: &VaultContractProxy) -> Option<u64> {
+    let txs = vault.all_pending_txs_desc(None, None).unwrap().txs;
+    txs.first().map(|tx| match tx {
+        Tx::InFlightStaking { id, .. } => *id,
+    })
+}
+
 #[test]
 fn unstaking() {
     let users = ["user1", "user2"];
@@ -300,6 +342,13 @@ fn unstaking() {
         )
         .call(users[0])
         .unwrap();
+    let last_tx = get_last_pending_tx_id(&vault).unwrap();
+    // Hardcoded commit_tx call (lack of IBC support yet)
+    vault
+        .vault_api_proxy()
+        .commit_tx(last_tx)
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     vault
         .stake_remote(
@@ -312,6 +361,11 @@ fn unstaking() {
         )
         .call(users[0])
         .unwrap();
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     vault
         .stake_remote(
@@ -324,6 +378,11 @@ fn unstaking() {
         )
         .call(users[1])
         .unwrap();
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     // Properly unstake some tokens
     // users[0] unstakes 50 from validators[0] - 150 left staken in 2 batches
@@ -583,6 +642,12 @@ fn distribution() {
         )
         .call(users[0])
         .unwrap();
+    // Hardcoded commit_tx call (lack of IBC support yet)
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     vault
         .stake_remote(
@@ -595,6 +660,11 @@ fn distribution() {
         )
         .call(users[0])
         .unwrap();
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     vault
         .stake_remote(
@@ -607,6 +677,11 @@ fn distribution() {
         )
         .call(users[1])
         .unwrap();
+    vault
+        .vault_api_proxy()
+        .commit_tx(get_last_pending_tx_id(&vault).unwrap())
+        .call(contract.contract_addr.as_str())
+        .unwrap();
 
     // Start with equal distribution:
     // 20 tokens for users[0]

contracts/provider/native-staking/src/local_staking_api.rs

@@ -10,6 +10,9 @@ use crate::contract::{NativeStakingContract, MAX_SLASH_PERCENTAGE, REPLY_ID_INST
 use crate::error::ContractError;
 use crate::msg::StakeMsg;
 
+// FIXME: Move to sylvia contract macro
+use crate::contract::BoundQuerier;
+
 #[contract]
 #[messages(local_staking_api as LocalStakingApi)]
 impl LocalStakingApi for NativeStakingContract<'_> {

contracts/provider/native-staking/src/native_staking_callback.rs

@@ -10,6 +10,9 @@ use mesh_native_staking_proxy::native_staking_callback::{self, NativeStakingCall
 use crate::contract::NativeStakingContract;
 use crate::error::ContractError;
 
+// FIXME: Move to sylvia contract macro
+use crate::contract::BoundQuerier;
+
 #[contract]
 #[messages(native_staking_callback as NativeStakingCallback)]
 impl NativeStakingCallback for NativeStakingContract<'_> {

contracts/provider/vault/Cargo.toml

@@ -20,6 +20,7 @@ mt = ["library", "sylvia/mt"]
 
 [dependencies]
 mesh-apis        = { workspace = true }
+mesh-sync        = { workspace = true }
 
 sylvia = { workspace = true }
 cosmwasm-schema  = { workspace = true }