Make API tokens required to connect to hypersync, and don't force a login for envio start

Author: JasoonS

codegenerator/cli/npm/envio/src/sources/HyperSyncSource.res

@@ -151,7 +151,7 @@ type options = {
   allEventSignatures: array<string>,
   shouldUseHypersyncClientDecoder: bool,
   eventRouter: EventRouter.t<Internal.evmEventConfig>,
-  apiToken: option<string>,
+  apiToken: option<string>, // this should be required (not an option)
   clientMaxRetries: int,
   clientTimeoutMillis: int,
   lowercaseAddresses: bool,
@@ -181,7 +181,7 @@ let make = (
     ~url=endpointUrl,
     ~apiToken,
     ~maxNumRetries=clientMaxRetries,
-    ~httpReqTimeoutMillis=clientTimeoutMillis, 
+    ~httpReqTimeoutMillis=clientTimeoutMillis,
     ~enableChecksumAddresses=!lowercaseAddresses,
   )
 

codegenerator/cli/src/commands.rs

@@ -364,7 +364,7 @@ pub mod login {
     use tokio::time::sleep;
 
     /// Default UI/API base URL. Change this constant to point to your deployment.
-    pub const AUTH_BASE_URL: &str = "http://localhost:3000";
+    pub const AUTH_BASE_URL: &str = "https://envio.dev";
 
     fn get_api_base_url() -> String {
         // Allow override via ENVIO_API_URL, otherwise use the constant above.
@@ -382,28 +382,9 @@ pub mod login {
         expires_in: i32,
     }
 
-    #[derive(Debug, Deserialize)]
-    struct User {
-        #[allow(dead_code)]
-        id: Option<String>,
-        #[allow(dead_code)]
-        name: Option<String>,
-        #[allow(dead_code)]
-        email: Option<String>,
-        #[allow(dead_code)]
-        #[serde(rename = "githubId")]
-        github_id: Option<String>,
-        #[allow(dead_code)]
-        #[serde(rename = "githubLogin")]
-        github_login: Option<String>,
-    }
-
     #[derive(Debug, Deserialize)]
     struct CliAuthStatus {
         completed: bool,
-        #[allow(dead_code)]
-        user: Option<User>,
-        #[allow(dead_code)]
         error: Option<String>,
         token: Option<String>,
     }
@@ -607,6 +588,30 @@ pub mod hypersync {
         TokenManager::new(SERVICE_NAME, HYPERSYNC_ACCOUNT).store_token(token)
     }
 
+    pub async fn get_hypersync_token() -> Result<Option<String>> {
+        // 1) If we already have a token in keyring, use it
+        if let Some(existing) = TokenManager::new(SERVICE_NAME, HYPERSYNC_ACCOUNT).get_token()? {
+            return Ok(Some(existing));
+        }
+
+        // 2) If we have a JWT, try to list existing tokens without creating a new one
+        let jwt = match get_stored_jwt()? {
+            Some(t) => t,
+            None => return Ok(None), // Not logged in; do not login or provision
+        };
+
+        let base = get_hypersync_tokens_base_url();
+        let client = reqwest::Client::new();
+        let tokens = list_api_tokens(&client, &base, &jwt)
+            .await
+            .unwrap_or_default();
+        if let Some(token) = tokens.get(0) {
+            store_api_token(token)?;
+            return Ok(Some(token.clone()));
+        }
+        Ok(None)
+    }
+
     pub async fn provision_and_get_token() -> Result<String> {
         let base = get_hypersync_tokens_base_url();
         let jwt = match get_stored_jwt()? {

codegenerator/cli/src/executor/mod.rs

@@ -76,7 +76,7 @@ pub async fn execute(command_line_args: CommandLineArgs) -> Result<()> {
 
                 commands::db_migrate::run_db_setup(&config, &persisted_state).await?;
             }
-            // Populate HyperSync API token from vault unless .env overrides
+            // During `start`, attempt to retrieve an existing HyperSync token without logging in or creating one.
             {
                 use crate::config_parsing::system_config::{DataSource, MainEvmDataSource};
                 let uses_hypersync = config.get_networks().iter().any(|n| match &n.sync_source {
@@ -86,13 +86,7 @@ pub async fn execute(command_line_args: CommandLineArgs) -> Result<()> {
                     DataSource::Fuel { .. } => true,
                 });
                 if uses_hypersync {
-                    // Do not prompt login for start; best-effort provision if possible
-                    if let Err(e) = commands::hypersync::provision_and_get_token().await {
-                        eprintln!(
-                            "Warning: could not provision HyperSync token automatically: {}",
-                            e
-                        );
-                    }
+                    let _ = commands::hypersync::get_hypersync_token().await;
                 }
             }
 

codegenerator/cli/templates/static/codegen/src/eventFetching/NetworkSources.res

@@ -21,22 +21,36 @@ let evm = (
     ->EventRouter.fromEvmEventModsOrThrow(~chain)
 
   let sources = switch hyperSync {
-  | Some(endpointUrl) => [
-      HyperSyncSource.make({
-        chain,
-        contracts,
-        endpointUrl,
-        allEventSignatures,
-        eventRouter,
-        shouldUseHypersyncClientDecoder: Env.Configurable.shouldUseHypersyncClientDecoder->Option.getWithDefault(
-          shouldUseHypersyncClientDecoder,
-        ),
-        apiToken: Env.envioApiToken,
-        clientMaxRetries: Env.hyperSyncClientMaxRetries,
-        clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
-        lowercaseAddresses,
-      }),
-    ]
+  | Some(endpointUrl) => {
+      switch Env.envioApiToken {
+      | Some(_) => ()
+      | None => {
+          Js.Console.error(
+            "HyperSync is configured as a datasource but ENVIO_API_TOKEN is not set.",
+          )
+          Js.Console.error(
+            "Please run 'envio login` to log in, or alternatively add your ENVIO_API_TOKEN to your project .env file.",
+          )
+          NodeJs.process->NodeJs.exitWithCode(Failure)
+        }
+      }
+      [
+        HyperSyncSource.make({
+          chain,
+          contracts,
+          endpointUrl,
+          allEventSignatures,
+          eventRouter,
+          shouldUseHypersyncClientDecoder: Env.Configurable.shouldUseHypersyncClientDecoder->Option.getWithDefault(
+            shouldUseHypersyncClientDecoder,
+          ),
+          apiToken: Env.envioApiToken,
+          clientMaxRetries: Env.hyperSyncClientMaxRetries,
+          clientTimeoutMillis: Env.hyperSyncClientTimeoutMillis,
+          lowercaseAddresses,
+        }),
+      ]
+    }
   | _ => []
   }
   rpcs->Js.Array2.forEach(({?syncConfig, url, sourceFor}) => {