feat: use config to resolve registry contract id

Author: willemneal

crates/stellar-registry-cli/src/bin/main.rs

@@ -1,15 +1,10 @@
 use clap::{CommandFactory, Parser};
 
-use stellar_registry_cli::{testnet, Root};
+use stellar_registry_cli::Root;
 
 #[tokio::main]
 async fn main() {
     let _ = dotenvy::dotenv().unwrap_or_default();
-    let contract_id = testnet::contract_id_strkey();
-    std::env::set_var("STELLAR_CONTRACT_ID", contract_id.to_string());
-    // std::env::set_var("SOROBAN_RPC_URL", testnet::rpc_url());
-    // std::env::set_var("SOROBAN_NETWORK_PASSPHRASE", testnet::network_passphrase());
-    // std::env::remove_var("SOROBAN_NETWORK");
     let mut root = Root::try_parse().unwrap_or_else(|e| {
         let mut cmd = Root::command();
         e.format(&mut cmd).exit();

crates/stellar-registry-cli/src/commands/deploy.rs

@@ -10,14 +10,14 @@ use soroban_sdk::xdr::{
     Transaction, TransactionExt, Uint256, VecM,
 };
 use stellar_cli::{
-    assembled::simulate_and_assemble_transaction, commands::contract::invoke, config, fee,
+    assembled::simulate_and_assemble_transaction, commands::contract::{arg_parsing, invoke}, config, fee,
     utils::rpc::get_remote_wasm_from_hash,
 };
 
 use soroban_rpc as rpc;
 pub use soroban_spec_tools::contract as contract_spec;
 
-use crate::testnet::{self, contract_address, invoke_registry};
+use crate::contract::NetworkContract;
 
 #[derive(Parser, Debug, Clone)]
 pub struct Cmd {
@@ -85,18 +85,19 @@ impl Cmd {
     }
 
     pub async fn hash(&self) -> Result<xdr::Hash, Error> {
-        let res = invoke_registry(
-            &["fetch_hash", "--wasm_name", &self.wasm_name],
-            &self.config,
-            &self.fee,
-        )
-        .await?;
+        let res = self
+            .config
+            .invoke_registry(
+                &["fetch_hash", "--wasm_name", &self.wasm_name],
+                Some(&self.fee),
+            )
+            .await?;
         let res = res.trim_matches('"');
         Ok(res.parse().unwrap())
     }
 
     pub async fn wasm(&self) -> Result<Vec<u8>, Error> {
-        Ok(get_remote_wasm_from_hash(&testnet::client()?, &self.hash().await?).await?)
+        Ok(get_remote_wasm_from_hash(&self.config.rpc_client()?, &self.hash().await?).await?)
     }
 
     pub async fn spec_entries(&self) -> Result<Vec<ScSpecEntry>, Error> {
@@ -106,22 +107,22 @@ impl Cmd {
     }
 
     async fn invoke(&self) -> Result<(), Error> {
-        let client = testnet::client()?;
+        let client = self.config.rpc_client()?;
         let key = self.config.key_pair()?;
         let config = &self.config;
 
         // Get the account sequence number
         let public_strkey =
             stellar_strkey::ed25519::PublicKey(key.verifying_key().to_bytes()).to_string();
 
-        let contract_address = contract_address();
-        let contract_id = &testnet::contract_id_strkey();
+        let contract_address = self.config.contract_sc_address()?;
+        let contract_id = &self.config.contract_id()?;
         let spec_entries = self.spec_entries().await?;
 
         let (args, signers) = if self.slop.is_empty() {
             (ScVal::Void, vec![])
         } else {
-            let res = stellar_cli::commands::contract::arg_parsing::build_host_function_parameters(
+            let res = arg_parsing::build_host_function_parameters(
                 contract_id,
                 &self.slop,
                 &spec_entries,
@@ -144,7 +145,7 @@ impl Cmd {
                     ));
                     (args, signers)
                 }
-                Err(stellar_cli::commands::contract::arg_parsing::Error::HelpMessage(help)) => {
+                Err(arg_parsing::Error::HelpMessage(help)) => {
                     println!("{help}");
                     return Ok(());
                 }

crates/stellar-registry-cli/src/commands/install.rs

@@ -3,11 +3,10 @@ use clap::Parser;
 use stellar_cli::{
     commands::contract::{fetch, invoke},
     config,
-    fee::Args,
 };
 use stellar_strkey::Contract;
 
-use crate::testnet;
+use crate::contract::NetworkContract;
 
 #[derive(Parser, Debug, Clone)]
 pub struct Cmd {
@@ -66,12 +65,7 @@ impl Cmd {
 
         // Use this.config directly
         eprintln!("Fetching contract ID via registry...");
-        let raw = testnet::invoke_registry(
-            &slop,
-            &self.config,
-            &Args::default(), // fee::Args::default()
-        )
-        .await?;
+        let raw = self.config.invoke_registry(&slop, None).await?;
 
         let contract_id = raw.trim_matches('"').to_string();
         Ok(contract_id.parse()?)

crates/stellar-registry-cli/src/commands/publish.rs

@@ -4,10 +4,10 @@ use clap::Parser;
 
 use soroban_sdk::xdr::{ScMetaEntry, ScMetaV0};
 use stellar_cli::{commands::contract::invoke, config, fee};
-
 pub use soroban_spec_tools::contract as contract_spec;
 
-use crate::testnet::invoke_registry;
+use crate::contract::NetworkContract;
+
 
 #[derive(Parser, Debug, Clone)]
 pub struct Cmd {
@@ -69,22 +69,18 @@ impl Cmd {
                 }
             }
         }));
-        // Use the provided author or the default keypair
-        let author = self.author.clone().unwrap_or_else(|| {
-            self.config
-                .key_pair()
-                .map(|key| {
-                    stellar_strkey::ed25519::PublicKey(key.verifying_key().to_bytes()).to_string()
-                })
-                .unwrap_or_default()
-        });
+        // Use the provided author or the source account
+        let author = if let Some(author) = self.author.clone() {
+            author
+        } else {
+            self.config.source_account().await?.to_string()
+        };
         args.push(format!("--author={author}"));
 
         // Pass config and fee to invoke_registry
-        invoke_registry(
+        self.config.invoke_registry(
             &args.iter().map(String::as_str).collect::<Vec<_>>(),
-            &self.config,
-            &self.fee,
+            Some(&self.fee),
         )
         .await?;
 

crates/stellar-registry-cli/src/contract.rs

@@ -1,8 +1,85 @@
 use sha2::{Digest, Sha256};
-use stellar_cli::xdr::{self, WriteXdr};
+
+use soroban_rpc as rpc;
+use stellar_cli::{
+    commands::{contract::invoke, NetworkRunnable},
+    config::{self, network::Network, UnresolvedContract},
+    xdr::{self, WriteXdr},
+};
+
+pub trait NetworkContract {
+    fn contract_id(&self) -> Result<stellar_strkey::Contract, config::Error>;
+
+    fn contract_sc_address(&self) -> Result<xdr::ScAddress, config::Error> {
+        Ok(xdr::ScAddress::Contract(xdr::Hash(self.contract_id()?.0)))
+    }
+
+    fn invoke_registry(
+        &self,
+        slop: &[&str],
+        fee: Option<&stellar_cli::fee::Args>,
+    ) -> impl std::future::Future<Output = Result<String, invoke::Error>> + Send;
+
+    fn rpc_client(&self) -> Result<rpc::Client, config::Error>;
+}
+
+impl NetworkContract for config::Args {
+    fn contract_id(&self) -> Result<stellar_strkey::Contract, config::Error> {
+        let Network {
+            network_passphrase, ..
+        } = &self.get_network()?;
+        let contract: UnresolvedContract = unsafe {
+            if let Ok(contract_id) = std::env::var("STELLAR_REGISTRY_CONTRACT_ID") {
+                contract_id.parse()
+            } else {
+                contract_id(&network_passphrase).to_string().parse()
+            }
+            .unwrap_unchecked()
+        };
+        Ok(contract.resolve_contract_id(&self.locator, network_passphrase)?)
+    }
+
+    async fn invoke_registry(
+        &self,
+        slop: &[&str],
+        fee: Option<&stellar_cli::fee::Args>,
+    ) -> Result<String, invoke::Error> {
+        invoke_registry(slop, self, fee).await
+    }
+
+    fn rpc_client(&self) -> Result<rpc::Client, config::Error> {
+        Ok(rpc::Client::new(&self.get_network()?.rpc_url)?)
+    }
+}
+
+pub fn build_invoke_cmd(
+    slop: &[&str],
+    config: &stellar_cli::config::Args,
+    fee: Option<&stellar_cli::fee::Args>,
+) -> Result<invoke::Cmd, config::Error> {
+    Ok(invoke::Cmd {
+        contract_id: UnresolvedContract::Resolved(config.contract_id()?),
+        slop: slop.iter().map(Into::into).collect(),
+        config: config.clone(),
+        fee: fee.cloned().unwrap_or_default(),
+        ..Default::default()
+    })
+}
+
+pub async fn invoke_registry(
+    slop: &[&str],
+    config: &stellar_cli::config::Args,
+    fee: Option<&stellar_cli::fee::Args>,
+) -> Result<String, invoke::Error> {
+    Ok(build_invoke_cmd(slop, config, fee)?
+        .run_against_rpc_server(Some(&stellar_cli::commands::global::Args::default()), None)
+        .await?
+        .into_result()
+        .expect("Failed to parse JSON"))
+}
 
 pub fn stellar_address() -> stellar_strkey::ed25519::PublicKey {
-    "GBMJ2WUAZXELW27JLKTGXM5ZQHS4MXVUPQRDQD47J6UKRYPYUFW64LT5"
+    "GBLTLNPISIK2JFDN42MXET7K7QLFSTPBAL5FLK7QUH2VM5HTCURFQGDK"
         .parse()
         .unwrap()
 }
@@ -25,3 +102,15 @@ pub fn contract_id(network_passphrase: &str) -> stellar_strkey::Contract {
         .expect("HashIdPreimage should not fail encoding to xdr");
     stellar_strkey::Contract(Sha256::digest(preimage_xdr).into())
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_contract_id() {
+        let contract_id = super::contract_id("Test SDF Future Network ; October 2022");
+        assert_eq!(
+            contract_id.to_string(),
+            "CBBL2SVHBQY35LY6IE64RHS5K2M7BXXV72KXS2CKV6MU4L3Y33HANUJ2".to_string()
+        );
+    }
+}

crates/stellar-registry-cli/src/lib.rs

@@ -5,7 +5,6 @@
 )]
 pub mod commands;
 pub mod contract;
-pub mod testnet;
 
 pub use commands::Root;
 use std::path::Path;