feat: use firebase instead of mixpanel in for event tracking (#32)

Co-authored-by: Diego Prats <diegoprats@Diegos-MacBook-Pro-m3.local>
Co-authored-by: Collin Jackson <collin@nexus.xyz>

.github/workflows/ci.yml

@@ -0,0 +1,64 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - "**"
+
+jobs:
+  build:
+    name: Lint CLI
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            clients/cli
+            proto
+
+      - name: Set up Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install protoc
+        uses: arduino/setup-protoc@v3
+
+      - name: Set up Rust cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: ./clients/cli
+
+      - name: Format
+        working-directory: clients/cli
+        run: |
+          rustfmt src/**/*.rs --check --edition 2021
+
+      - name: Build
+        working-directory: clients/cli
+        run: |
+          cargo build --profile=ci-build
+
+      - name: Run cargo clippy
+        working-directory: clients/cli
+        run: |
+          cargo clippy --profile=ci-build --no-deps --all-targets --workspace -- -D warnings
+
+      - name: Test
+        working-directory: clients/cli
+        run: |
+          cargo test --profile=ci-build --tests
+
+      - name: Ensure checked in generated files are up to date
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then \
+              echo "There are uncommitted changes in working tree after building."; \
+              git status; \
+              git --no-pager diff; \
+              exit 1; \
+          else \
+              echo "Git working tree is clean"; \
+          fi;

clients/cli/Cargo.lock

@@ -1567,7 +1567,7 @@ dependencies = [
 
 [[package]]
 name = "nexus-network"
-version = "0.1.0"
+version = "0.3.4"
 dependencies = [
  "ark-bn254",
  "ark-crypto-primitives",

clients/cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nexus-network"
-version = "0.3.2"
+version = "0.3.4"
 edition = "2021"
 
 [[bin]]
@@ -10,6 +10,23 @@ path = "src/prover.rs"
 [build-dependencies]
 prost-build = "0.13"
 
+[profile.dev]
+opt-level = 1
+
+[profile.release]
+lto = "fat"
+strip = true
+codegen-units = 1
+
+[profile.ci-build]
+inherits = "dev"
+opt-level = 0
+debug = 0
+strip = "none"
+lto = false
+codegen-units = 256
+incremental = true
+
 [dependencies]
 async-stream = "0.3"
 clap = { version = "4.5", features = ["derive"] }
@@ -83,8 +100,3 @@ ark-vesta = { git = "https://github.com/arkworks-rs/curves/", rev = "8c0256a" }
 ark-bls12-381 = { git = "https://github.com/arkworks-rs/curves/", rev = "3fded1f" }
 
 zstd-sys = { git = "https://github.com/gyscos/zstd-rs" }
-
-[profile.release]
-strip = true
-lto = true
-codegen-units = 1

clients/cli/README.md

@@ -1,6 +1,6 @@
 # Network CLI
 
-The command line interface (CLI) lets you run a Nexus prover node.
+The command line interface (CLI) lets you run a prover node and contribute proofs to the Nexus network.
 It is the highest-performance option for proving.
 
 ## Prerequisites
@@ -48,6 +48,7 @@ add `NONINTERACTIVE=1` before `sh`.
 
 * Only the latest version of the CLI is currently supported.
 * Prebuilt binaries are not yet available.
+* Linking email to prover id is currently available on the web version only.
 * Counting cycles proved is not yet available in the CLI.
 * Only proving is supported. Submitting programs to the network is in private beta.
 To request an API key, contact us at growth@nexus.xyz.
@@ -55,4 +56,4 @@ To request an API key, contact us at growth@nexus.xyz.
 ## Resources
 
 * [Network FAQ](https://nexus.xyz/network#network-faqs)
-* [Discord channel](https://discord.gg/nexus-xyz)
+* [Discord server](https://discord.gg/nexus-xyz)

clients/cli/src/analytics.rs

@@ -1,4 +1,4 @@
-use crate::config::analytics_token;
+use crate::config::{analytics_id, analytics_api_key};
 use chrono::Datelike;
 use chrono::Timelike;
 use reqwest::header::{ACCEPT, CONTENT_TYPE};
@@ -16,14 +16,27 @@ pub fn track(
 ) {
     println!("{}", description);
 
-    let token = analytics_token(ws_addr_string);
+    let firebase_app_id = analytics_id(ws_addr_string);
-    if token.is_empty() {
+    let firebase_api_key = analytics_api_key(ws_addr_string);
+    if firebase_app_id.is_empty() {
         return;
     }
     let local_now = chrono::offset::Local::now();
+
+    // For tracking events, we use the Firebase Measurement Protocol
+    // Firebase is mostly designed for mobile and web apps, but for our use case of a CLI,
+    // we can use the Measurement Protocol to track events by POST to a URL. 
+    // The only thing that may be unexpected is that the URL we use includes a firebase key
+
+    // Firebase format for properties for Measurement protocol: 
+    // https://developers.google.com/analytics/devguides/collection/protocol/ga4/reference?client_type=firebase#payload
+    // https://developers.google.com/analytics/devguides/collection/protocol/ga4/reference?client_type=firebase#payload_query_parameters
     let mut properties = json!({
-        "token": token,
         "time": SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis(),
+        // app_instance_id is the standard key Firebase uses this key to track the same user across sessions
+        // It is a bit redundant, but I wanted to keep the recommended format Firebase uses to minimize surprises
+        // I still left the distinct_id key as well for backwards compatibility
+        "app_instance_id": event_properties["prover_id"],  
         "distinct_id": event_properties["prover_id"],
         "prover_type": "volunteer",
         "client_type": "cli",
@@ -36,15 +49,27 @@ pub fn track(
     for (k, v) in event_properties.as_object().unwrap() {
         properties[k] = v.clone();
     }
+
+    // Firebase format for events
     let body = json!({
-        "event": event_name,
+        "app_instance_id": event_properties["prover_id"],
-        "properties": properties
+        "events": [{
+            "name": event_name,
+            "params": properties
+        }],
     });
+
     tokio::spawn(async move {
         let client = reqwest::Client::new();
+
         let _ = client
-            .post("https://api.mixpanel.com/track?ip=1")
+            // URL is the Google Analytics endpoint for Firebase: https://stackoverflow.com/questions/50355752/firebase-analytics-from-remote-rest-api
-            .body(format!("[{}]", body.to_string()))
+            .post(format!(
+                "https://www.google-analytics.com/mp/collect?firebase_app_id={}&api_secret={}",
+                firebase_app_id,
+                firebase_api_key
+            ))
+            .body(format!("[{}]", body))
             .header(ACCEPT, "text/plain")
             .header(CONTENT_TYPE, "application/json")
             .send()

clients/cli/src/config.rs

@@ -1,18 +1,78 @@
+// Debug version of analytics_id
 #[cfg(debug_assertions)]
-pub fn analytics_token(_ws_addr_string: &str) -> String {
+pub fn analytics_id(_ws_addr_string: &str) -> String {
     // Use one of the tokens in the release version if debugging analytics
-    return "".into();
+    "".into()
+}
+
+// Debug version of analytics_api_key
+#[cfg(debug_assertions)]
+pub fn analytics_api_key(_ws_addr_string: &str) -> String {
+    // Use one of the tokens in the release version if debugging analytics
+    "".into()
+}
+
+// The following enum is used to determine the environment from the web socket string
+#[derive(Debug)]
+#[cfg(not(debug_assertions))]
+enum Environment {
+    Dev,
+    Staging,
+    Beta,
+    Unknown,
+}
+
+// The web socket addresses for the different environments
+#[cfg(not(debug_assertions))]
+mod web_socket_urls {
+    pub const DEV: &str = "wss://dev.orchestrator.nexus.xyz:443/";
+    pub const STAGING: &str = "wss://staging.orchestrator.nexus.xyz:443/";
+    pub const BETA: &str = "wss://beta.orchestrator.nexus.xyz:443/";
+}
+
+// the firebase APP IDS by environment
+#[cfg(not(debug_assertions))]
+mod firebase {
+    pub const DEV_APP_ID: &str = "1:954530464230:web:f0a14de14ef7bcdaa99627";
+    pub const STAGING_APP_ID: &str = "1:222794630996:web:1758d64a85eba687eaaac1";
+    pub const BETA_APP_ID: &str = "1:279395003658:web:04ee2c524474d683d75ef3";
+
+    // Analytics keys for the different environments
+    // These are keys that allow the measurement protocol to write to the analytics database
+    // They are not sensitive. Worst case, if a malicious actor obtains the secret, they could potentially send false or misleading data to your GA4 property
+    pub const DEV_API_SECRET: &str = "8ySxiKrtT8a76zClqqO8IQ";
+    pub const STAGING_API_SECRET: &str = "OI7H53soRMSDWfJf1ittHQ";
+    pub const BETA_API_SECRET: &str = "gxxzKAQLSl-uYI0eKbIi_Q";
+}
+
+// Release versions (existing code)
+#[cfg(not(debug_assertions))]
+pub fn analytics_id(ws_addr_string: &str) -> String {
+
+    // Determine the environment from the web socket string (ws_addr_string)
+    let env = match ws_addr_string {
+        web_socket_urls::DEV => Environment::Dev,
+        web_socket_urls::STAGING => Environment::Staging,
+        web_socket_urls::BETA => Environment::Beta,
+        _ => Environment::Unknown,
+    };
+    
+    // Return the appropriate Firebase App ID based on the environment
+    match env {
+        Environment::Dev => firebase::DEV_APP_ID.to_string(),
+        Environment::Staging => firebase::STAGING_APP_ID.to_string(),
+        Environment::Beta => firebase::BETA_APP_ID.to_string(),
+        Environment::Unknown => String::new(),
+    }
 }
 
 #[cfg(not(debug_assertions))]
-pub fn analytics_token(ws_addr_string: &str) -> String {
+pub fn analytics_api_key(ws_addr_string: &str) -> String {
-    if ws_addr_string.starts_with("wss://dev.orchestrator.nexus.xyz:443/") {
+    match ws_addr_string {
-        return "504d4d443854f2cd10e2e385aca81aa4".into();
+        web_socket_urls::DEV => firebase::DEV_API_SECRET.to_string(),
-    } else if ws_addr_string.starts_with("wss://staging.orchestrator.nexus.xyz:443/") {
+        web_socket_urls::STAGING => firebase::STAGING_API_SECRET.to_string(),
-        return "30bcb58893992aabc5aec014e7b903d2".into();
+        web_socket_urls::BETA => firebase::BETA_API_SECRET.to_string(),
-    } else if ws_addr_string.starts_with("wss://beta.orchestrator.nexus.xyz:443/") {
+        _ => String::new(),
-        return "3c16d3853f4258414c9c9109bbbdef0e".into();
+    }
-    } else {
-        return "".into();
-    };
 }
+

clients/cli/src/prover.rs

@@ -32,8 +32,8 @@ use nexus_core::{
         init_circuit_trace, key::CanonicalSerialize, pp::gen_vm_pp, prove_seq_step, types::*,
     },
 };
+use rand::RngCore;
 use zstd::stream::Encoder;
-use rand::{ RngCore };
 
 #[derive(Parser, Debug)]
 struct Args {
@@ -118,7 +118,7 @@ async fn main() {
         contents: Some(prover_request::Contents::Registration(
             ProverRequestRegistration {
                 prover_type: ProverType::Volunteer.into(),
-                prover_id: prover_id.clone().into(),
+                prover_id: prover_id.clone(),
                 estimated_proof_cycles_hertz: None,
             },
         )),
@@ -127,21 +127,25 @@ async fn main() {
     let mut retries = 0;
     let max_retries = 5;
 
-    loop {
+    while let Err(e) = client
-        if let Err(e) = client.send(Message::Binary(registration.encode_to_vec())).await {
+        .send(Message::Binary(registration.encode_to_vec()))
-            eprintln!("Failed to send message: {:?}, attempt {}/{}", e, retries + 1, max_retries);
+        .await
+    {
+        eprintln!(
+            "Failed to send message: {:?}, attempt {}/{}",
+            e,
+            retries + 1,
+            max_retries
+        );
 
-            retries += 1;
+        retries += 1;
-            if retries >= max_retries {
+        if retries >= max_retries {
-                eprintln!("Max retries reached, exiting...");
+            eprintln!("Max retries reached, exiting...");
-                break;
-            }
-
-            // Add a delay before retrying
-            tokio::time::sleep(tokio::time::Duration::from_secs(u64::pow(2, retries))).await;
-        } else {
             break;
         }
+
+        // Add a delay before retrying
+        tokio::time::sleep(tokio::time::Duration::from_secs(u64::pow(2, retries))).await;
     }
 
     track(
@@ -180,7 +184,7 @@ async fn main() {
         );
 
         let mut vm: NexusVM<MerkleTrie> =
-            parse_elf(&elf_bytes.as_ref()).expect("error loading and parsing RISC-V instruction");
+            parse_elf(elf_bytes.as_ref()).expect("error loading and parsing RISC-V instruction");
         vm.syscalls.set_input(&input);
 
         // TODO(collinjackson): Get outputs
@@ -244,10 +248,10 @@ async fn main() {
             completed_fraction = steps_proven as f32 / steps_to_prove as f32;
             let progress = ProverRequest {
                 contents: Some(prover_request::Contents::Progress(Progress {
-                    completed_fraction: completed_fraction,
+                    completed_fraction,
                     steps_in_trace: total_steps as i32,
                     steps_to_prove: steps_to_prove as i32,
-                    steps_proven: steps_proven as i32,
+                    steps_proven,
                 })),
             };
             let progress_duration = SystemTime::now().duration_since(progress_time).unwrap();
@@ -255,7 +259,10 @@ async fn main() {
             let proof_cycles_hertz = k as f64 * 1000.0 / progress_duration.as_millis() as f64;
             track(
                 "progress".into(),
-                format!("Proved step {} at {:.2} proof cycles/sec.", step, proof_cycles_hertz),
+                format!(
+                    "Proved step {} at {:.2} proof cycles/sec.",
+                    step, proof_cycles_hertz
+                ),
                 &ws_addr_string,
                 json!({
                     "completed_fraction": completed_fraction,
@@ -273,21 +280,22 @@ async fn main() {
 
             let mut retries = 0;
             let max_retries = 5;
-            loop {
+            while let Err(e) = client.send(Message::Binary(progress.encode_to_vec())).await {
-                if let Err(e) = client.send(Message::Binary(progress.encode_to_vec())).await {
+                eprintln!(
-                    eprintln!("Failed to send message: {:?}, attempt {}/{}", e, retries + 1, max_retries);
+                    "Failed to send message: {:?}, attempt {}/{}",
-        
+                    e,
-                    retries += 1;
+                    retries + 1,
-                    if retries >= max_retries {
+                    max_retries
-                        eprintln!("Max retries reached, exiting...");
+                );
-                        break;
+
-                    }
+                retries += 1;
-        
+                if retries >= max_retries {
-                    // Add a delay before retrying
+                    eprintln!("Max retries reached, exiting...");
-                    tokio::time::sleep(tokio::time::Duration::from_secs(u64::pow(2, retries))).await;
-                } else {
                     break;
                 }
+
+                // Add a delay before retrying
+                tokio::time::sleep(tokio::time::Duration::from_secs(u64::pow(2, retries))).await;
             }
 
             if step == end - 1 {
@@ -305,14 +313,18 @@ async fn main() {
                     })),
                 };
                 let duration = SystemTime::now().duration_since(start_time).unwrap();
-                let proof_cycles_hertz = cycles_proven as f64 * 1000.0 / duration.as_millis() as f64;
+                let proof_cycles_hertz =
+                    cycles_proven as f64 * 1000.0 / duration.as_millis() as f64;
                 client
                     .send(Message::Binary(response.encode_to_vec()))
                     .await
-                    .unwrap();                                               
+                    .unwrap();
                 track(
                     "proof".into(),
-                    format!("Proof sent! Overall speed was {:.2} proof cycles/sec.", proof_cycles_hertz),
+                    format!(
+                        "Proof sent! Overall speed was {:.2} proof cycles/sec.",
+                        proof_cycles_hertz
+                    ),
                     &ws_addr_string,
                     json!({
                         "proof_duration_sec": duration.as_secs(),

proto/generate_protobufs.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-mkdir -p clients/flutter/lib/src/generated
-protoc --experimental_allow_proto3_optional --dart_out=grpc:clients/flutter/lib/src/generated -Iproto proto/orchestrator.proto
-dart format clients/flutter/lib/src/generated
-(cd clients/dummy_client && cargo build || echo clients/dummy_client not found, possibly due to a sparse checkout.)
-(cd clients/cli && cargo build || echo clients/cli not found, possibly due to a sparse checkout.)
-(cd orchestrator && cargo build || echo orchestrator/ not found, possibly due a sparse checkout.)