Use env vars for keychain and api URLs

cli/src/command/auth/login.rs

@@ -15,13 +15,14 @@ use serde::Deserialize;
 use slot::{
     account::Account,
     api::Client,
-    browser, constant,
+    browser,
     credential::Credentials,
     graphql::auth::{
         me::{ResponseData, Variables},
         AccountTryFromGraphQLError, Me,
     },
     server::LocalServer,
+    vars,
 };
 use tokio::sync::mpsc::Sender;
 
@@ -34,7 +35,9 @@ impl LoginArgs {
         let port = server.local_addr()?.port();
         let callback_uri = format!("http://localhost:{port}/callback");
 
-        let url = format!("https://x.cartridge.gg/slot/auth?callback_uri={callback_uri}");
+        let url = vars::get_cartridge_keychain_url();
+
+        let url = format!("{url}/slot/auth?callback_uri={callback_uri}");
 
         browser::open(&url)?;
         server.start().await?;
@@ -131,15 +134,15 @@ async fn handler(
 
             Ok(Redirect::permanent(&format!(
                 "{}/slot/auth/success",
-                constant::CARTRIDGE_KEYCHAIN_URL
+                vars::get_cartridge_keychain_url()
             )))
         }
         None => {
             error!("User denied consent. Try again.");
 
             Ok(Redirect::permanent(&format!(
                 "{}/slot/auth/failure",
-                constant::CARTRIDGE_KEYCHAIN_URL
+                vars::get_cartridge_keychain_url()
             )))
         }
     }

cli/src/command/deployments/fork.rs

@@ -5,7 +5,7 @@ use clap::Args;
 use slot::graphql::deployments::fork_deployment::ForkDeploymentForkDeployment::KatanaConfig;
 use slot::graphql::deployments::{fork_deployment::*, ForkDeployment};
 use slot::graphql::{GraphQLQuery, Response};
-use slot::{api::Client, credential::Credentials};
+use slot::{api::Client, credential::Credentials, vars};
 use starknet::providers::{jsonrpc::HttpTransport, JsonRpcClient, Provider};
 use url::Url;
 
@@ -72,9 +72,10 @@ impl ForkArgs {
                 let block_number = if let Some(block_number) = config.fork_block_number {
                     block_number
                 } else {
+                    let url = vars::get_cartridge_api_url();
                     // Workaround to get latest block number. Perhaps Katana could default to latest if none is supplied
                     let rpc_client = JsonRpcClient::new(HttpTransport::new(Url::parse(&format!(
-                        "https://api.cartridge.gg/x/{}/katana",
+                        "{url}/x/{}/katana",
                         self.project
                     ))?));
                     rpc_client.block_number().await?

slot/src/api.rs

@@ -4,7 +4,7 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use url::Url;
 
 use crate::error::Error;
-use crate::{constant, credential::AccessToken};
+use crate::{credential::AccessToken, vars};
 
 #[derive(Debug)]
 pub struct Client {
@@ -18,7 +18,7 @@ impl Client {
         Self {
             access_token: None,
             client: reqwest::Client::new(),
-            base_url: Url::parse(constant::CARTRIDGE_API_URL).expect("valid url"),
+            base_url: Url::parse(vars::get_cartridge_api_url().as_str()).expect("valid url"),
         }
     }
 

slot/src/lib.rs

@@ -3,11 +3,11 @@
 pub mod account;
 pub mod api;
 pub mod browser;
-pub mod constant;
 pub mod credential;
 pub mod graphql;
 pub mod server;
 pub mod session;
+pub mod vars;
 
 pub(crate) mod error;
 pub(crate) mod utils;

slot/src/session.rs

@@ -15,9 +15,9 @@ use url::Url;
 use crate::credential::Credentials;
 use crate::error::Error;
 use crate::utils::{self};
-use crate::{browser, server::LocalServer};
+use crate::{browser, server::LocalServer, vars};
 
-const SESSION_CREATION_PAGE: &str = "https://x.cartridge.gg/slot/session";
+const SESSION_CREATION_PATH: &str = "/slot/session";
 const SESSION_FILE_BASE_NAME: &str = "session.json";
 
 /// A policy defines what action can be performed by the session key.
@@ -146,7 +146,9 @@ where
 /// Creates a new session token for the given user. This will open a browser to the Cartridge
 /// Controller keychain page to prompt user to create a new session for the given policies and
 /// network. Returns the newly created session token.
-#[tracing::instrument(name = "create_session", level = "trace", skip(rpc_url), fields(policies = policies.len()))]
+#[tracing::instrument(name = "create_session", level = "trace", skip(rpc_url), fields(
+    policies = policies.len()
+))]
 pub async fn create_user_session<U>(
     username: &str,
     rpc_url: U,
@@ -168,7 +170,8 @@ fn open_session_creation_page(
     policies: &[Policy],
 ) -> anyhow::Result<Receiver<SessionDetails>> {
     let params = prepare_query_params(username, rpc_url, policies)?;
-    let url = format!("{SESSION_CREATION_PAGE}?{params}");
+    let host = vars::get_cartridge_keychain_url();
+    let url = format!("{host}{SESSION_CREATION_PATH}?{params}");
 
     let (tx, rx) = channel::<SessionDetails>(1);
     let server = callback_server(tx)?;

slot/src/vars.rs

@@ -0,0 +1,16 @@
+use std::env;
+
+pub fn get_cartridge_keychain_url() -> String {
+    get_env("CARTRIDGE_KEYCHAIN_URL", "https://x.cartridge.gg")
+}
+
+pub fn get_cartridge_api_url() -> String {
+    get_env("CARTRIDGE_API_URL", "https://api.cartridge.gg")
+}
+
+pub fn get_env(key: &str, default: &str) -> String {
+    match env::var(key) {
+        Ok(val) => val,
+        Err(_e) => default.to_string(),
+    }
+}