Added disconnect script

framework/packages/abstract-interface/src/ibc.rs

@@ -85,6 +85,16 @@
             connect_one_way_to(remote_abstr, self, interchain)?;
             Ok(())
         }
+
+        /// This is used for completely removing a connection between two Abstract connections.
+        pub fn disconnect_from(
+            &self,
+            remote_abstr: &Abstract<Chain>,
+        ) -> Result<(), AbstractInterfaceError> {
+            disconnect_one_way_from(self, remote_abstr)?;
+            disconnect_one_way_from(remote_abstr, self)?;
+            Ok(())
+        }
     }
 
     impl AbstractIbc<Daemon> {
@@ -144,6 +154,26 @@
         Ok(())
     }
 
+    pub fn disconnect_one_way_from<Chain: IbcQueryHandler>(
+        abstr_client: &Abstract<Chain>,
+        abstr_host: &Abstract<Chain>,
+    ) -> Result<(), AbstractInterfaceError> {
+        // First we get the chain names to remove them from host and client
+        let chain1_id = abstr_client.ibc.client.environment().chain_id();
+        let chain1_name = TruncatedChainId::from_chain_id(&chain1_id);
+
+        let chain2_id = abstr_host.ibc.client.environment().chain_id();
+        let chain2_name = TruncatedChainId::from_chain_id(&chain2_id);
+
+        // First, we remove on the client
+        abstr_client.ibc.client.remove_host(chain2_name.clone())?;
+
+        // Then we remove on the host
+        abstr_host.ibc.host.remove_chain_proxy(chain1_name)?;
+
+        Ok(())
+    }
+
     pub fn list_ibc_infrastructures<Chain: CwEnv>(
         chain: Chain,
     ) -> abstract_std::ibc_client::ListIbcInfrastructureResponse {

framework/packages/abstract-std/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-authors     = { workspace = true }
+authors = { workspace = true }
 description = "Abstract contract interfaces and storage layouts"
-edition     = { workspace = true }
-license     = { workspace = true }
-name        = "abstract-std"
-readme      = "README.md"
-repository  = "https://github.com/AbstractSDK/abstract"
-version     = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+name = "abstract-std"
+readme = "README.md"
+repository = "https://github.com/AbstractSDK/abstract"
+version = { workspace = true }
 
 [lints]
 workspace = true
@@ -15,25 +15,24 @@ workspace = true
 # for quicker tests, cargo test --lib
 
 [dependencies]
-anybuf          = { workspace = true }
 cosmwasm-schema = { workspace = true }
-cosmwasm-std    = { workspace = true, features = ["iterator"] }
+cosmwasm-std = { workspace = true, features = ["iterator"] }
 cw-address-like = { workspace = true }
-cw-asset        = { workspace = true }
-cw-blob         = { workspace = true }
-cw-clearable    = { workspace = true }
-cw-controllers  = { workspace = true }
-cw-orch         = { workspace = true }
-cw-ownable      = { workspace = true }
+cw-asset = { workspace = true }
+cw-blob = { workspace = true }
+cw-clearable = { workspace = true }
+cw-controllers = { workspace = true }
+cw-orch = { workspace = true }
+cw-ownable = { workspace = true }
 cw-storage-plus = { workspace = true }
-cw-utils        = { workspace = true }
-cw2             = { workspace = true }
-cw20            = { workspace = true }
-schemars        = { workspace = true }
-semver          = { workspace = true, features = ["serde"] }
-serde           = { workspace = true }
-sha2            = { version = "0.10.8", default-features = false }
-thiserror       = { workspace = true }
+cw-utils = { workspace = true }
+cw2 = { workspace = true }
+cw20 = { workspace = true }
+schemars = { workspace = true }
+semver = { workspace = true, features = ["serde"] }
+serde = { workspace = true }
+sha2 = { version = "0.10.8", default-features = false }
+thiserror = { workspace = true }
 
 ## Stringify function names
 function_name = { version = "0.3.0" }
@@ -43,7 +42,7 @@ workspace-hack = { version = "0.1", path = "../../workspace-hack" }
 
 [dev-dependencies]
 abstract-testing = { path = "../abstract-testing" }
-anyhow           = { workspace = true }
-coverage-helper  = { workspace = true }
-cw20-base        = { workspace = true }
-rstest           = { workspace = true }
+anyhow = { workspace = true }
+coverage-helper = { workspace = true }
+cw20-base = { workspace = true }
+rstest = { workspace = true }

interchain/scripts/src/bin/full_deploy.rs

@@ -1,16 +1,10 @@
 use abstract_interface::{Abstract, AccountI};
 use abstract_std::objects::gov_type::GovernanceDetails;
-use std::{
-    fs::{self, File},
-    io::BufReader,
-    net::TcpStream,
-};
 
-use abstract_scripts::{assert_wallet_balance, DeploymentStatus, SUPPORTED_CHAINS};
+use abstract_scripts::{assert_wallet_balance, SUPPORTED_CHAINS};
 
 use clap::Parser;
 use cw_orch::{daemon::networks::parse_network, prelude::*};
-use reqwest::Url;
 use tokio::runtime::Runtime;
 
 pub const ABSTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");

interchain/scripts/src/bin/ibc_disconnect.rs

@@ -0,0 +1,85 @@
+use abstract_interface::Abstract;
+use clap::Parser;
+use cw_orch::daemon::DaemonState;
+use cw_orch::prelude::*;
+
+use networks::parse_network;
+
+fn get_daemon(
+    chain: ChainInfo,
+    mnemonic: Option<String>,
+    deployment_id: Option<String>,
+    state: Option<DaemonState>,
+) -> cw_orch::anyhow::Result<Daemon> {
+    let mut builder = DaemonBuilder::new(chain);
+    if let Some(state) = state {
+        builder.state(state);
+    }
+    if let Some(mnemonic) = mnemonic {
+        builder.mnemonic(mnemonic);
+    }
+    if let Some(deployment_id) = deployment_id {
+        builder.deployment_id(deployment_id);
+    }
+    Ok(builder.build()?)
+}
+
+pub fn get_deployment_id(src_chain: &ChainInfo, dst_chain: &ChainInfo) -> String {
+    format!("{}-->{}", src_chain.chain_id, dst_chain.chain_id)
+}
+
+fn connect(
+    (src_chain, src_mnemonic): (ChainInfo, Option<String>),
+    (dst_chain, dst_mnemonic): (ChainInfo, Option<String>),
+) -> cw_orch::anyhow::Result<()> {
+    let src_daemon = get_daemon(src_chain.clone(), src_mnemonic.clone(), None, None)?;
+    let dst_daemon = get_daemon(
+        dst_chain.clone(),
+        dst_mnemonic,
+        None,
+        Some(src_daemon.state()),
+    )?;
+
+    let src_abstract = Abstract::load_from(src_daemon.clone())?;
+    let dst_abstract = Abstract::load_from(dst_daemon.clone())?;
+    src_abstract.disconnect_from(&dst_abstract)?;
+
+    Ok(())
+}
+
+#[derive(Parser, Default, Debug)]
+#[command(author, version, about, long_about = None)]
+struct Arguments {
+    #[arg(short, long)]
+    src: String,
+
+    #[arg(short, long)]
+    dst: String,
+}
+
+fn main() {
+    dotenv::dotenv().unwrap();
+    env_logger::init();
+
+    let args = Arguments::parse();
+
+    // let networks = vec![abstract_scripts::ROLLKIT_TESTNET];
+
+    let src_network = parse_network(&args.src).unwrap();
+    let dst_network = parse_network(&args.dst).unwrap();
+
+    if let Err(ref err) = connect((src_network, None), (dst_network, None)) {
+        log::error!("{}", err);
+        err.chain()
+            .skip(1)
+            .for_each(|cause| log::error!("because: {}", cause));
+
+        // The backtrace is not always generated. Try to run this example
+        // with `$env:RUST_BACKTRACE=1`.
+        //    if let Some(backtrace) = e.backtrace() {
+        //        log::debug!("backtrace: {:?}", backtrace);
+        //    }
+
+        ::std::process::exit(1);
+    }
+}