Helloworld program and tooling

rust/Cargo.toml

@@ -22,6 +22,7 @@ members = [
     "sealevel/libraries/serializable-account-meta",
     "sealevel/libraries/test-transaction-utils",
     "sealevel/libraries/test-utils",
+    "sealevel/programs/helloworld",
     "sealevel/programs/hyperlane-sealevel-token",
     "sealevel/programs/hyperlane-sealevel-token-collateral",
     "sealevel/programs/hyperlane-sealevel-token-native",

rust/agents/relayer/src/msg/metadata/base.rs

@@ -74,9 +74,14 @@ impl MetadataBuilder for BaseMetadataBuilder {
         ism_address: H256,
         message: &HyperlaneMessage,
     ) -> Result<Option<Vec<u8>>> {
-        const CTX: &str = "When fetching module type";
-        let ism = self.build_ism(ism_address).await.context(CTX)?;
-        let module_type = ism.module_type().await.context(CTX)?;
+        let ism = self
+            .build_ism(ism_address)
+            .await
+            .context("When building ISM")?;
+        let module_type = ism
+            .module_type()
+            .await
+            .context("When fetching module type")?;
         let base = self.clone_with_incremented_depth()?;
 
         let metadata_builder: Box<dyn MetadataBuilder> = match module_type {
@@ -94,7 +99,7 @@ impl MetadataBuilder for BaseMetadataBuilder {
         metadata_builder
             .build(ism_address, message)
             .await
-            .context(CTX)
+            .context("When building metadata")
     }
 }
 

rust/hyperlane-core/src/traits/interchain_security_module.rs

@@ -4,12 +4,23 @@ use async_trait::async_trait;
 use auto_impl::auto_impl;
 use borsh::{BorshDeserialize, BorshSerialize};
 use num_derive::FromPrimitive;
+use serde::{Deserialize, Serialize};
 
 use crate::{ChainResult, HyperlaneContract, HyperlaneMessage, U256};
 
 /// Enumeration of all known module types
 #[derive(
-    FromPrimitive, Clone, Debug, Default, Copy, PartialEq, Eq, BorshDeserialize, BorshSerialize,
+    FromPrimitive,
+    Clone,
+    Debug,
+    Default,
+    Copy,
+    PartialEq,
+    Eq,
+    BorshDeserialize,
+    BorshSerialize,
+    Serialize,
+    Deserialize,
 )]
 #[cfg_attr(feature = "strum", derive(strum::Display))]
 pub enum ModuleType {

rust/sealevel/client/Cargo.toml

@@ -31,4 +31,5 @@ hyperlane-sealevel-igp = { path = "../programs/hyperlane-sealevel-igp", features
 hyperlane-sealevel-token-collateral = { path = "../programs/hyperlane-sealevel-token-collateral", features = ["no-entrypoint"] }
 hyperlane-sealevel-token-lib = { path = "../libraries/hyperlane-sealevel-token" }
 hyperlane-sealevel-token-native = { path = "../programs/hyperlane-sealevel-token-native", features = ["no-entrypoint"] }
-hyperlane-sealevel-validator-announce = { path = "../programs/validator-announce", features = ["no-entrypoint"] }
+hyperlane-sealevel-validator-announce = { path = "../programs/validator-announce", features = ["no-entrypoint"] }
+hyperlane-sealevel-hello-world = { path = "../programs/helloworld" }

rust/sealevel/client/src/artifacts.rs

@@ -0,0 +1,59 @@
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+use hyperlane_core::H256;
+use solana_program::pubkey::Pubkey;
+
+use std::{fs::File, io::Write, path::Path, str::FromStr};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub(crate) struct SingularProgramIdArtifact {
+    #[serde(with = "crate::serde::serde_pubkey")]
+    pub program_id: Pubkey,
+}
+
+impl From<Pubkey> for SingularProgramIdArtifact {
+    fn from(val: Pubkey) -> Self {
+        SingularProgramIdArtifact { program_id: val }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct HexAndBase58ProgramIdArtifact {
+    hex: String,
+    base58: String,
+}
+
+impl From<H256> for HexAndBase58ProgramIdArtifact {
+    fn from(val: H256) -> Self {
+        HexAndBase58ProgramIdArtifact {
+            hex: format!("0x{}", hex::encode(val)),
+            base58: Pubkey::new_from_array(val.to_fixed_bytes()).to_string(),
+        }
+    }
+}
+
+impl From<&HexAndBase58ProgramIdArtifact> for Pubkey {
+    fn from(val: &HexAndBase58ProgramIdArtifact) -> Self {
+        Pubkey::from_str(&val.base58).unwrap()
+    }
+}
+
+pub(crate) fn write_json<T>(path: &Path, program_id: T)
+where
+    T: Serialize,
+{
+    let json = serde_json::to_string_pretty(&program_id).unwrap();
+    println!("Writing to file {} contents:\n{}", path.display(), json);
+
+    let mut file = File::create(path).expect("Failed to create file");
+    file.write_all(json.as_bytes())
+        .expect("Failed write JSON to file");
+}
+
+pub(crate) fn read_json<T>(path: &Path) -> T
+where
+    T: DeserializeOwned,
+{
+    let file = File::open(path).expect("Failed to open JSON file");
+    serde_json::from_reader(file).expect("Failed to read JSON file")
+}

rust/sealevel/client/src/context.rs

@@ -26,6 +26,7 @@ pub(crate) struct Context {
     payer_keypair: Option<PayerKeypair>,
     pub commitment: CommitmentConfig,
     pub initial_instructions: RefCell<Vec<InstructionWithDescription>>,
+    pub require_tx_approval: bool,
 }
 
 pub(crate) struct InstructionWithDescription {
@@ -58,13 +59,15 @@ impl Context {
         payer_keypair: Option<PayerKeypair>,
         commitment: CommitmentConfig,
         initial_instructions: RefCell<Vec<InstructionWithDescription>>,
+        require_tx_approval: bool,
     ) -> Self {
         Self {
             client,
             payer_pubkey,
             payer_keypair,
             commitment,
             initial_instructions,
+            require_tx_approval,
         }
     }
 
@@ -183,6 +186,13 @@ impl<'ctx, 'rpc> TxnBuilder<'ctx, 'rpc> {
             return None;
         }
 
+        // Print the tx as an indication for what's about to happen
+        self.pretty_print_transaction();
+
+        if self.ctx.require_tx_approval {
+            wait_for_user_confirmation();
+        }
+
         let client = self.client.unwrap_or(&self.ctx.client);
 
         let recent_blockhash = client.get_latest_blockhash().unwrap();

rust/sealevel/client/src/core.rs

@@ -4,10 +4,12 @@ use solana_program::pubkey::Pubkey;
 use solana_sdk::signature::Signer;
 
 use std::collections::HashMap;
-use std::{fs::File, io::Write, path::Path};
+use std::{fs::File, path::Path};
 
 use crate::{
+    artifacts::{read_json, write_json},
     cmd_utils::{create_and_write_keypair, create_new_directory, deploy_program},
+    multisig_ism::deploy_multisig_ism_message_id,
     Context, CoreCmd, CoreDeploy, CoreSubCmd,
 };
 use hyperlane_core::H256;
@@ -21,7 +23,12 @@ pub(crate) fn process_core_cmd(mut ctx: Context, cmd: CoreCmd) {
             let core_dir = create_new_directory(&chain_dir, "core");
             let key_dir = create_new_directory(&core_dir, "keys");
 
-            let ism_program_id = deploy_multisig_ism_message_id(&mut ctx, &core, &key_dir);
+            let ism_program_id = deploy_multisig_ism_message_id(
+                &mut ctx,
+                &core.built_so_dir,
+                core.use_existing_keys,
+                &key_dir,
+            );
 
             let mailbox_program_id = deploy_mailbox(&mut ctx, &core, &key_dir, ism_program_id);
 
@@ -44,43 +51,6 @@ pub(crate) fn process_core_cmd(mut ctx: Context, cmd: CoreCmd) {
     }
 }
 
-fn deploy_multisig_ism_message_id(ctx: &mut Context, cmd: &CoreDeploy, key_dir: &Path) -> Pubkey {
-    let (keypair, keypair_path) = create_and_write_keypair(
-        key_dir,
-        "hyperlane_sealevel_multisig_ism_message_id-keypair.json",
-        cmd.use_existing_keys,
-    );
-    let program_id = keypair.pubkey();
-
-    deploy_program(
-        ctx.payer_keypair_path(),
-        keypair_path.to_str().unwrap(),
-        cmd.built_so_dir
-            .join("hyperlane_sealevel_multisig_ism_message_id.so")
-            .to_str()
-            .unwrap(),
-        &ctx.client.url(),
-    );
-
-    println!(
-        "Deployed Multisig ISM Message ID at program ID {}",
-        program_id
-    );
-
-    // Initialize
-    let instruction = hyperlane_sealevel_multisig_ism_message_id::instruction::init_instruction(
-        program_id,
-        ctx.payer_pubkey,
-    )
-    .unwrap();
-
-    ctx.new_txn().add(instruction).send_with_payer();
-
-    println!("Initialized Multisig ISM Message ID ");
-
-    program_id
-}
-
 fn deploy_mailbox(
     ctx: &mut Context,
     core: &CoreDeploy,
@@ -325,55 +295,23 @@ fn deploy_igp(ctx: &mut Context, core: &CoreDeploy, key_dir: &Path) -> (Pubkey,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-pub(crate) struct CoreProgramIds {
-    #[serde(with = "serde_pubkey")]
+pub struct CoreProgramIds {
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub mailbox: Pubkey,
-    #[serde(with = "serde_pubkey")]
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub validator_announce: Pubkey,
-    #[serde(with = "serde_pubkey")]
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub multisig_ism_message_id: Pubkey,
-    #[serde(with = "serde_pubkey")]
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub igp_program_id: Pubkey,
-    #[serde(with = "serde_pubkey")]
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub overhead_igp_account: Pubkey,
-    #[serde(with = "serde_pubkey")]
+    #[serde(with = "crate::serde::serde_pubkey")]
     pub igp_account: Pubkey,
 }
 
-mod serde_pubkey {
-    use borsh::BorshDeserialize;
-    use serde::{Deserialize, Deserializer, Serializer};
-    use solana_sdk::pubkey::Pubkey;
-    use std::str::FromStr;
-
-    #[derive(Deserialize)]
-    #[serde(untagged)]
-    enum RawPubkey {
-        String(String),
-        Bytes(Vec<u8>),
-    }
-
-    pub fn serialize<S: Serializer>(k: &Pubkey, ser: S) -> Result<S::Ok, S::Error> {
-        ser.serialize_str(&k.to_string())
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(de: D) -> Result<Pubkey, D::Error> {
-        match RawPubkey::deserialize(de)? {
-            RawPubkey::String(s) => Pubkey::from_str(&s).map_err(serde::de::Error::custom),
-            RawPubkey::Bytes(b) => Pubkey::try_from_slice(&b).map_err(serde::de::Error::custom),
-        }
-    }
-}
-
 fn write_program_ids(core_dir: &Path, program_ids: CoreProgramIds) {
-    let json = serde_json::to_string_pretty(&program_ids).unwrap();
-    let path = core_dir.join("program-ids.json");
-
-    println!("Writing program IDs to {}:\n{}", path.display(), json);
-
-    let mut file = File::create(path).expect("Failed to create keypair file");
-    file.write_all(json.as_bytes())
-        .expect("Failed to write program IDs to file");
+    write_json(&core_dir.join("program-ids.json"), program_ids);
 }
 
 pub(crate) fn read_core_program_ids(
@@ -386,6 +324,5 @@ pub(crate) fn read_core_program_ids(
         .join(chain)
         .join("core")
         .join("program-ids.json");
-    let file = File::open(path).expect("Failed to open program IDs file");
-    serde_json::from_reader(file).expect("Failed to read program IDs file")
+    read_json(&path)
 }