feat: update resolution of contract id to prepare for deploying to main net (#74)

Author: willemneal

.github/workflows/rust.yml

@@ -29,8 +29,10 @@ jobs:
       - run: sudo apt-get update && sudo apt-get install -y libudev-dev libdbus-1-dev pkg-config # required for the machine to build properly
       - uses: taiki-e/install-action@nextest
       - uses: taiki-e/install-action@just
+      - uses: cargo-bins/cargo-binstall@main
       - name: Run cargo fmt
         run: cargo fmt --all -- --check
+      - run: just setup
       - name: build since clippy needs contracts to be built
         run: just build
       - name: Run cargo clippy

Cargo.lock

@@ -37,4 +37,4 @@ lto = true
 
 
 [workspace.lints.clippy]
-unexpected_cfgs = "allow"
+

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "stellar-registry-contract"
+name = "registry"
 description = "A crate for managing and deploying smart contracts on the Soroban blockchain."
 version = "0.1.0"
 authors = ["Aha Labs <hello@ahalabs.dev>"]

contracts/registry/Cargo.toml

@@ -11,12 +11,12 @@ fn default_version() -> soroban_sdk::String {
     to_string("0.0.0")
 }
 
-stellar_registry::import_contract_client!(stellar_registry_contract);
+stellar_registry::import_contract_client!(registry);
 // Equivalent to:
 
-// mod stellar_registry_contract {
+// mod registry {
 //     use super::soroban_sdk;
-//     soroban_sdk::contractimport!(file = "../../../../target/stellar/stellar_registry_contract.wasm");
+//     soroban_sdk::contractimport!(file = "../../../../target/stellar/registry.wasm");
 // }
 
 fn init() -> (SorobanContractClient<'static>, Address) {
@@ -26,11 +26,7 @@ fn init() -> (SorobanContractClient<'static>, Address) {
     let address = Address::generate(env);
     let client = SorobanContractClient::new(
         env,
-        &env.register_at(
-            &contract_id,
-            stellar_registry_contract::WASM,
-            (address.clone(),),
-        ),
+        &env.register_at(&contract_id, registry::WASM, (address.clone(),)),
     );
     (client, address)
 }
@@ -46,16 +42,14 @@ fn handle_error_cases() {
         Ok(Error::NoSuchContractPublished)
     );
 
-    let wasm_hash = env
-        .deployer()
-        .upload_contract_wasm(stellar_registry_contract::WASM);
+    let wasm_hash = env.deployer().upload_contract_wasm(registry::WASM);
 
     assert_matches!(
         client.try_fetch_hash(name, &None).unwrap_err(),
         Ok(Error::NoSuchContractPublished)
     );
 
-    let bytes = Bytes::from_slice(env, stellar_registry_contract::WASM);
+    let bytes = Bytes::from_slice(env, registry::WASM);
     env.mock_all_auths();
     let version = default_version();
     client.publish(name, address, &bytes, &version);
@@ -81,14 +75,12 @@ fn returns_most_recent_version() {
     let env = env();
     let name = &to_string("publisher");
     // client.register_name(address, name);
-    let bytes = Bytes::from_slice(env, stellar_registry_contract::WASM);
+    let bytes = Bytes::from_slice(env, registry::WASM);
     env.mock_all_auths();
     let version = default_version();
     client.publish(name, address, &bytes, &version);
     let fetched_hash = client.fetch_hash(name, &None);
-    let wasm_hash = env
-        .deployer()
-        .upload_contract_wasm(stellar_registry_contract::WASM);
+    let wasm_hash = env.deployer().upload_contract_wasm(registry::WASM);
     assert_eq!(fetched_hash, wasm_hash);
 
     let second_hash: BytesN<32> = BytesN::random(env);
@@ -137,16 +129,21 @@ fn validate_version() {
     let (client, address) = &init();
     let env = env();
     let name = &to_string("registry");
-    let bytes = Bytes::from_slice(env, stellar_registry_contract::WASM);
+    let bytes = Bytes::from_slice(env, registry::WASM);
     env.mock_all_auths();
     let version = default_version();
     client.publish(name, address, &bytes, &version);
     assert_eq!(
-        client.try_publish(name, address, &bytes, &to_string("0.0.0"),),
+        client.try_publish(name, address, &bytes, &version),
         Err(Ok(Error::VersionMustBeGreaterThanCurrent))
     );
     assert_eq!(
         client.try_publish(name, address, &bytes, &to_string("0.  0.0"),),
         Err(Ok(Error::InvalidVersion))
     );
+    client.publish(name, address, &bytes, &to_string("0.0.1"));
+    assert_eq!(
+        client.try_publish(name, address, &bytes, &version),
+        Err(Ok(Error::VersionMustBeGreaterThanCurrent))
+    );
 }

contracts/registry/src/test.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/bin/main.rs

@@ -10,14 +10,16 @@ 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 +87,20 @@ 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),
+                true,
+            )
+            .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 +110,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 +148,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/deploy.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, true).await?;
 
         let contract_id = raw.trim_matches('"').to_string();
         Ok(contract_id.parse()?)