cargo_tangle/command/deploy/

tangle.rs

use std::path::PathBuf;

use crate::command::deploy::mbsm::deploy_mbsm_if_needed;
use blueprint_chain_setup::tangle::deploy::{Opts, deploy_to_tangle};
use blueprint_contexts::tangle::TangleClientContext;
use blueprint_crypto::sp_core::{SpEcdsa, SpSr25519};
use blueprint_crypto::tangle_pair_signer::TanglePairSigner;
use blueprint_keystore::backends::Backend;
use blueprint_keystore::{Keystore, KeystoreConfig};
use blueprint_testing_utils::tangle::harness::{ENDOWED_TEST_NAMES, generate_env_from_node_id};
use blueprint_testing_utils::tangle::keys::inject_tangle_key;
use dialoguer::console::style;
use tangle_subxt::subxt::tx::Signer;
use tempfile::TempDir;
use tokio::fs;
use tokio::signal;
use url::Url;

/// Deploy a blueprint to the Tangle
///
/// # Errors
///
/// Returns a `color_eyre::Report` if an error occurs during deployment.
pub async fn deploy_tangle(
    http_rpc_url: String,
    ws_rpc_url: String,
    package: Option<String>,
    devnet: bool,
    keystore_path: Option<PathBuf>,
    manifest_path: PathBuf,
) -> Result<(), color_eyre::Report> {
    if !devnet {
        let keystore_path = if let Some(keystore_uri) = keystore_path {
            Some(keystore_uri)
        } else if PathBuf::from("./keystore").exists() {
            Some(PathBuf::from("./keystore"))
        } else {
            None
        };

        let (signer, signer_evm) = if let Some(keystore_uri) = keystore_path {
            let keystore_config = KeystoreConfig::new().fs_root(keystore_uri.clone());
            let keystore = Keystore::new(keystore_config)?;

            let sr25519_public = keystore.first_local::<SpSr25519>()?;
            let sr25519_pair = keystore.get_secret::<SpSr25519>(&sr25519_public)?;
            let sr25519_signer = TanglePairSigner::new(sr25519_pair.0);

            let ecdsa_public = keystore.first_local::<SpEcdsa>()?;
            let ecdsa_pair = keystore.get_secret::<SpEcdsa>(&ecdsa_public)?;
            let ecdsa_signer = TanglePairSigner::new(ecdsa_pair.0);
            let alloy_key = ecdsa_signer
                .alloy_key()
                .map_err(|e| color_eyre::Report::msg(format!("Failed to get Alloy key: {}", e)))?;
            (Some(sr25519_signer), Some(alloy_key))
        } else {
            (None, None)
        };

        let _ = deploy_to_tangle(Opts {
            pkg_name: package,
            http_rpc_url,
            ws_rpc_url,
            manifest_path,
            signer,
            signer_evm,
        })
        .await?;

        return Ok(());
    }

    println!(
        "{}",
        style("Starting local Tangle testnet...").cyan().bold()
    );

    let temp_dir = TempDir::new()?;
    let temp_path = temp_dir.path().to_path_buf();
    let deploy_dir = temp_path.join("deploy_dir");
    fs::create_dir_all(&deploy_dir).await?;

    // Start Local Tangle Node
    let node = blueprint_chain_setup::tangle::run(
        blueprint_chain_setup::tangle::NodeConfig::new(false).with_log_target("evm", "trace"),
    )
    .await?;
    let http_endpoint = Url::parse(&format!("http://127.0.0.1:{}", node.ws_port()))?;
    let ws_endpoint = Url::parse(&format!("ws://127.0.0.1:{}", node.ws_port()))?;

    // Create test keystore for Alice (to act as the user)
    let test_keystore_path = PathBuf::from("./test-keystore");
    fs::create_dir_all(&test_keystore_path).await?;
    inject_tangle_key(&test_keystore_path, "//Alice")
        .map_err(|e| color_eyre::Report::msg(format!("Failed to inject Alice's key: {}", e)))?;

    // Create deploy keystore for Bob (for deployment)
    let deploy_keystore_path = PathBuf::from("./deploy-keystore");
    fs::create_dir_all(&deploy_keystore_path).await?;
    inject_tangle_key(&deploy_keystore_path, "//Bob")
        .map_err(|e| color_eyre::Report::msg(format!("Failed to inject Bob's key: {}", e)))?;

    // Set up Alice's environment for MBSM deployment
    let alice_env = generate_env_from_node_id(
        ENDOWED_TEST_NAMES[0],
        http_endpoint.clone(),
        ws_endpoint.clone(),
        deploy_dir.as_path(),
    )
    .await?;

    let alice_client = alice_env.tangle_client().await?;

    println!(
        "{}",
        style("Checking if MBSM needs to be deployed...").cyan()
    );

    // Set up Alice's signers for MBSM deployment
    let alice_keystore_config =
        KeystoreConfig::new().fs_root(test_keystore_path.to_string_lossy().to_string());
    let alice_keystore = Keystore::new(alice_keystore_config)?;

    let alice_sr25519_public = alice_keystore.first_local::<SpSr25519>()?;
    let alice_sr25519_pair = alice_keystore.get_secret::<SpSr25519>(&alice_sr25519_public)?;
    let alice_sr25519_signer = TanglePairSigner::new(alice_sr25519_pair.0);

    let alice_ecdsa_public = alice_keystore.first_local::<SpEcdsa>()?;
    let alice_ecdsa_pair = alice_keystore.get_secret::<SpEcdsa>(&alice_ecdsa_public)?;
    let alice_ecdsa_signer = TanglePairSigner::new(alice_ecdsa_pair.0);
    let alice_alloy_key = alice_ecdsa_signer
        .alloy_key()
        .map_err(|e| color_eyre::Report::msg(format!("Failed to get Alice's Alloy key: {}", e)))?;

    // Set up Bob's signers for blueprint deployment
    let deploy_keystore_uri = deploy_keystore_path.to_string_lossy().to_string();
    let bob_keystore_config = KeystoreConfig::new().fs_root(deploy_keystore_uri.clone());
    let bob_keystore = Keystore::new(bob_keystore_config)?;

    let bob_sr25519_public = bob_keystore.first_local::<SpSr25519>()?;
    let bob_sr25519_pair = bob_keystore.get_secret::<SpSr25519>(&bob_sr25519_public)?;
    let bob_sr25519_signer = TanglePairSigner::new(bob_sr25519_pair.0);

    let bob_ecdsa_public = bob_keystore.first_local::<SpEcdsa>()?;
    let bob_ecdsa_pair = bob_keystore.get_secret::<SpEcdsa>(&bob_ecdsa_public)?;
    let bob_ecdsa_signer = TanglePairSigner::new(bob_ecdsa_pair.0);
    let bob_alloy_key = bob_ecdsa_signer
        .alloy_key()
        .map_err(|e| color_eyre::Report::msg(format!("Failed to get Bob's Alloy key: {}", e)))?;

    deploy_mbsm_if_needed(
        ws_endpoint.clone(),
        &alice_client,
        &alice_sr25519_signer,
        alice_alloy_key.clone(),
    )
    .await?;

    println!(
        "{}",
        style(format!(
            "Tangle node running at HTTP: {}, WS: {}",
            http_endpoint, ws_endpoint
        ))
        .green()
    );

    println!(
        "{}",
        style("Deploying blueprint to local Tangle testnet using Bob's account...").cyan()
    );
    let blueprint_id = deploy_to_tangle(Opts {
        pkg_name: package,
        http_rpc_url: http_endpoint.to_string(),
        ws_rpc_url: ws_endpoint.to_string(),
        manifest_path,
        signer: Some(bob_sr25519_signer),
        signer_evm: Some(bob_alloy_key),
    })
    .await?;

    // Get Alice's account ID for display
    let alice_account_id = alice_sr25519_signer.account_id();

    println!("\n{}", style("Local Tangle Testnet Active").green().bold());
    println!(
        "{}",
        style(format!("Blueprint ID: {}", blueprint_id)).green()
    );
    println!(
        "{}",
        style(format!("Alice Account ID: {}", alice_account_id)).green()
    );
    println!(
        "\n{}",
        style(
            "If your blueprint was just generated from the template, you can follow the demo below:"
        )
        .cyan()
        .bold()
    );
    println!(
        "{}",
        style("1. Open a new terminal window, leaving this one running").dim()
    );
    println!(
        "\n{}",
        style("2. Register to your blueprint with Alice's account:").dim()
    );
    println!(
        "   {}",
        style(format!(
            "cargo tangle blueprint register --blueprint-id {} --keystore-uri ./test-keystore",
            blueprint_id
        ))
        .yellow()
    );
    println!("\n{}", style("3. Request service with Bob's account (we will use Alice's account as the target operator):").dim());
    println!("   {}", style(format!("cargo tangle blueprint request-service --blueprint-id {} --target-operators {} --value 0 --keystore-uri ./deploy-keystore", blueprint_id, alice_account_id)).yellow());
    println!("\n{}", style("4. List all service requests:").dim());
    println!(
        "   {}",
        style("cargo tangle blueprint ls".to_string()).yellow()
    );
    println!("\n{}", style("5. Accept the service request (request ID is 0 if you are following this demo, otherwise it will be from the request you want to accept):").dim());
    println!(
        "   {}",
        style("cargo tangle blueprint accept --request-id 0 --keystore-uri ./test-keystore")
            .yellow()
    );
    println!("\n{}", style("6. Run the blueprint:").dim());
    println!(
        "   {}",
        style(
            "cargo tangle blueprint run --protocol tangle --keystore-path ./test-keystore"
                .to_string()
        )
        .yellow()
    );
    println!(
        "\n{}",
        style("7. Open another terminal window, leaving this one running").dim()
    );
    println!(
        "\n{}",
        style("8. Submit a job for the Running Blueprint to process").dim()
    );
    println!("   {}", style(format!("cargo tangle blueprint submit --job 0 --blueprint-id {} --service-id 0 --watcher --keystore-uri ./deploy-keystore", blueprint_id)).yellow());

    println!(
        "\n{}",
        style("The local Tangle testnet will continue running for testing purposes.")
            .cyan()
            .bold()
    );
    println!(
        "{}",
        style("It will remain active so you can interact with your deployed blueprint.").cyan()
    );
    println!(
        "{}",
        style("Press Ctrl+C to stop the testnet when you're done testing...").dim()
    );

    // Wait for Ctrl+C to keep the testnet running
    signal::ctrl_c().await?;
    println!("{}", style("\nShutting down devnet...").yellow());

    // Clean up keystores
    println!("{}", style("Cleaning up keystores...").dim());
    if let Err(e) = fs::remove_dir_all(&test_keystore_path).await {
        println!("Warning: Failed to remove test keystore: {}", e);
    }
    if let Err(e) = fs::remove_dir_all(&deploy_keystore_path).await {
        println!("Warning: Failed to remove deploy keystore: {}", e);
    }

    Ok(())
}