Merge branch 'main' into feature/dynamic-chainname-fetch

kairos-cli/build.rs

@@ -0,0 +1,20 @@
+use std::env;
+use std::fs;
+use std::path::Path;
+
+fn main() {
+    // Path
+    let session_binaries_dir = env::var("PATH_TO_SESSION_BINARIES")
+        .expect("PATH_TO_SESSION_BINARIES environment variable is not set");
+
+    // Get the output directory set by Cargo.
+    let out_dir = env::var("OUT_DIR").expect("OUT_DIR not set");
+    let source_path = Path::new(&session_binaries_dir).join("deposit-session-optimized.wasm");
+    let dest_path = Path::new(&out_dir).join("deposit-session-optimized.wasm");
+
+    // Copy the file from the source to the destination
+    fs::copy(&source_path, dest_path).expect("Failed to copy WASM file");
+
+    // Print out a message to re-run this script if the source file changes.
+    println!("cargo:rerun-if-changed={}", source_path.display());
+}

kairos-cli/src/client.rs

@@ -9,8 +9,6 @@ use kairos_server::PublicKey;
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 use std::fmt;
-use std::fs;
-use std::path::Path;
 
 #[cfg(feature = "database")]
 use kairos_data::transaction::{TransactionFilter, Transactions};
@@ -55,20 +53,13 @@ impl From<reqwest::Error> for KairosClientError {
 
 pub fn deposit(
     base_url: &Url,
+    deposit_session_wasm_bytes: &[u8],
     depositor_secret_key: &SecretKey,
     chain_name: &str,
     contract_hash: &ContractHash,
     amount: impl Into<U512>,
     recipient: casper_client_types::PublicKey,
 ) -> Result<DeployHash, KairosClientError> {
-    let deposit_session_wasm_path =
-        Path::new(env!("PATH_TO_SESSION_BINARIES")).join("deposit-session-optimized.wasm");
-    let deposit_session_wasm_bytes = fs::read(&deposit_session_wasm_path).unwrap_or_else(|err| {
-        panic!(
-            "Failed to read the deposit session wasm as bytes from file: {:?}.\n{}",
-            deposit_session_wasm_path, err
-        )
-    });
     let deposit_session = ExecutableDeployItem::new_module_bytes(
         deposit_session_wasm_bytes.into(),
         runtime_args! {

kairos-cli/src/commands/deposit.rs

@@ -1,16 +1,22 @@
+use std::fs;
+use std::path::PathBuf;
+
 use crate::client;
 use crate::common::args::{
     AmountArg, ChainNameArg, ContractHashArg, PrivateKeyPathArg, RecipientArg,
 };
 use crate::error::CliError;
 
 use casper_client_types::{crypto::SecretKey, ContractHash};
-use clap::Parser;
+use clap::{Args as ClapArgs, Parser};
 use hex::FromHex;
 use reqwest::Url;
 
 use kairos_crypto::error::CryptoError;
 
+const DEFAULT_DEPOSIT_SESSION_WASM: &[u8] =
+    include_bytes!(concat!(env!("OUT_DIR"), "/deposit-session-optimized.wasm"));
+
 #[derive(Parser, Debug)]
 pub struct Args {
     #[clap(flatten)]
@@ -22,6 +28,8 @@ pub struct Args {
     #[clap(flatten)]
     recipient: RecipientArg,
     #[clap(flatten)]
+    session_path: SessionPathArg,
+    #[clap(flatten)]
     chain_name: ChainNameArg,
 }
 
@@ -46,8 +54,21 @@ pub fn run(args: Args, kairos_server_address: Url) -> Result<String, CliError> {
         Some(name) => name,
     };
 
+    let deposit_session_wasm: Vec<u8> = match args.session_path.field {
+        Some(deposit_session_wasm_path) => {
+            fs::read(&deposit_session_wasm_path).unwrap_or_else(|err| {
+                panic!(
+                    "Failed to read the deposit session wasm as bytes from file: {:?}.\n{}",
+                    deposit_session_wasm_path, err
+                )
+            })
+        }
+        None => DEFAULT_DEPOSIT_SESSION_WASM.to_vec(),
+    };
+
     client::deposit(
         &kairos_server_address,
+        &deposit_session_wasm,
         &depositor_secret_key,
         &chain_name,
         &contract_hash,
@@ -68,3 +89,15 @@ pub fn run(args: Args, kairos_server_address: Url) -> Result<String, CliError> {
         output
     })
 }
+
+#[derive(ClapArgs, Debug)]
+pub struct SessionPathArg {
+    #[arg(
+        id = "session-path",
+        long,
+        short = 's',
+        value_name = "PATH",
+        help = "Path to the custom WASM session code for deposit"
+    )]
+    pub field: Option<PathBuf>,
+}

kairos-cli/src/commands/fetch.rs

@@ -11,17 +11,17 @@ use chrono::NaiveDateTime;
 pub struct Args {
     #[arg(long, short, value_name = "PUBLIC_KEY_HEX")]
     sender: Option<String>,
-    #[arg(long, short, value_name = "ISO8601_TIMESTAMP")]
+    #[arg(long, short = 't', value_name = "ISO8601_TIMESTAMP")]
     min_timestamp: Option<NaiveDateTime>,
-    #[arg(long, short, value_name = "ISO8601_TIMESTAMP")]
+    #[arg(long, short = 'T', value_name = "ISO8601_TIMESTAMP")]
     max_timestamp: Option<NaiveDateTime>,
-    #[arg(long, short, value_name = "NUM_MOTES")]
+    #[arg(long, short = 'm', value_name = "NUM_MOTES")]
     min_amount: Option<u64>,
-    #[arg(long, short, value_name = "NUM_MOTES")]
+    #[arg(long, short = 'M', value_name = "NUM_MOTES")]
     max_amount: Option<u64>,
     #[arg(long, short, value_name = "PUBLIC_KEY_HEX")]
     recipient: Option<String>,
-    #[arg(long, short, value_name = "TRANSACTION_TYPE", value_enum)]
+    #[arg(long, short = 'x', value_name = "TRANSACTION_TYPE", value_enum)]
     transaction_type: Option<TransactionType>,
 }
 

kairos-cli/src/commands/run_cctl.rs

@@ -1,4 +1,4 @@
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 use casper_client_types::{runtime_args, RuntimeArgs};
 use kairos_test_utils::cctl::{CCTLNetwork, DeployableContract};
@@ -16,10 +16,10 @@ pub fn run() -> Result<String, CliError> {
             path: contract_wasm_path,
         };
         println!("Deploying contract...");
-        let chainspec_path = Path::new(env!("CCTL_CHAINSPEC"));
-        let config_path = Path::new(env!("CCTL_CONFIG"));
+        let chainspec_path = PathBuf::from(std::env::var("CCTL_CHAINSPEC").unwrap());
+        let config_path = PathBuf::from(std::env::var("CCTL_CONFIG").unwrap());
 
-        let network = CCTLNetwork::run(None, Some(contract_to_deploy), Some(chainspec_path), Some(config_path))
+        let network = CCTLNetwork::run(None, Some(contract_to_deploy), Some(chainspec_path.as_path()), Some(config_path.as_path()))
             .await
             .unwrap();
 

kairos-data/src/transaction.rs

@@ -51,7 +51,7 @@ pub async fn get(
             let mut query = transactions::table.into_boxed::<diesel::pg::Pg>();
 
             if let Some(sender) = filter.sender {
-                query = query.filter(transactions::public_key.eq(sender));
+                query = query.filter(transactions::public_key.eq(sender.to_lowercase()));
             }
             if let Some(min_timestamp) = filter.min_timestamp {
                 query = query.filter(transactions::timestamp.ge(min_timestamp));
@@ -66,7 +66,7 @@ pub async fn get(
                 query = query.filter(transactions::amount.le(BigDecimal::from(max_amount)));
             }
             if let Some(recipient) = filter.recipient {
-                query = query.filter(transactions::recipient.eq(recipient));
+                query = query.filter(transactions::recipient.eq(recipient.to_lowercase()));
             }
             if let Some(transaction_type) = filter.transaction_type {
                 query = query.filter(transactions::trx.eq(transaction_type));

kairos-prover/kairos-prover-risc0-server/Cargo.toml

@@ -14,7 +14,7 @@ metal = [ "risc0-zkvm/metal", "disable-dev-mode" ]
 
 [dependencies]
 methods = { path = "../methods" }
-risc0-zkvm = { version="=1.0.2", default-features=false }
+risc0-zkvm = { version="=1.0.3", default-features=false }
 
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

kairos-prover/kairos-verifier-risc0-lib/Cargo.toml

@@ -11,6 +11,6 @@ disable-dev-mode = [ "risc0-zkvm/disable-dev-mode" ]
 
 
 [dependencies]
-risc0-zkvm = { version = "=1.0.2", default-features = false, optional = true }
+risc0-zkvm = { version = "=1.0.3", default-features = false, optional = true }
 kairos-circuit-logic = { path = "../kairos-circuit-logic", features = ["serde", "borsh"], default-features = false, optional = true }
 borsh = { version = "1", default-features = false, optional = true }

kairos-prover/methods/Cargo.toml

@@ -5,5 +5,5 @@ edition.workspace = true
 license.workspace = true
 
 [build-dependencies]
-risc0-binfmt = "=1.0.2"
+risc0-binfmt = "=1.0.3"
 kairos-verifier-risc0-lib = { path = "../kairos-verifier-risc0-lib", default-features = false }

kairos-prover/profiling/Cargo.toml

@@ -6,7 +6,7 @@ license.workspace = true
 
 [dependencies]
 methods = { path = "../methods" }
-risc0-zkvm = "=1.0.2"
+risc0-zkvm = "=1.0.3"
 
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

kairos-server/Cargo.toml

@@ -47,6 +47,8 @@ reqwest = { version = "0.12", features = ["json"] }
 casper-event-toolkit = { git = "https://github.com/koxu1996/casper-event-toolkit.git", version = "0.1.3" }
 thiserror = "1.0"
 chrono = "0.4.38"
+risc0-zkvm = { version="=1.0.3", default-features=false }
+backoff = { version = "0.4", features = ["tokio", "futures"]}
 
 [dev-dependencies]
 proptest = "1"

kairos-server/src/state.rs

@@ -5,6 +5,8 @@ mod trie;
 use std::collections::HashSet;
 use std::{sync::Arc, thread};
 
+use kairos_circuit_logic::ProofOutputs;
+use risc0_zkvm::Receipt;
 use tokio::{
     sync::{mpsc, RwLock},
     task,
@@ -94,17 +96,18 @@ impl BatchStateManager {
 
                 if res.status().is_success() {
                     tracing::info!("Proving server returned success");
-                    let proof_serialized = res.bytes().await.unwrap_or_else(|e| {
-                        tracing::error!("Could not read response from proving server: {}", e);
-                        panic!("Could not read response from proving server: {}", e);
-                    });
+                    let (_proof_outputs, receipt): (ProofOutputs, Receipt) =
+                        res.json().await.unwrap_or_else(|e| {
+                            tracing::error!("Could not parse response from proving server: {}", e);
+                            panic!("Could not parse response from proving server: {}", e);
+                        });
 
                     if let Some(secret_key) = secret_key.as_ref() {
                         submit_proof_to_contract(
                             secret_key,
                             contract_hash,
                             casper_rpc.clone(),
-                            proof_serialized.to_vec(),
+                            serde_json::to_vec(&receipt).expect("Could not serialize receipt"),
                         )
                         .await
                     } else {