wip

Author: kariy

crates/cartridge/src/vrf/bootstrap.rs

@@ -95,7 +95,7 @@ pub fn derive_vrf_accounts(
 ) -> Result<VrfDerivedAccounts> {
     // vrf-server expects a u64 secret, so derive one from the account key.
     let secret_key = vrf_secret_key_from_account_key(source_private_key);
-    let public_key = generate_public_key(scalar_from_felt(Felt::from(secret_key)));
+    let public_key = generate_public_key(scalar_from_felt(secret_key.into()));
     let vrf_public_key_x = felt_from_field(public_key.x)?;
     let vrf_public_key_y = felt_from_field(public_key.y)?;
 
@@ -154,7 +154,6 @@ pub async fn bootstrap_vrf(config: &VrfBootstrapConfig) -> Result<VrfBootstrapRe
         chain_id_felt,
         ExecutionEncoding::New,
     );
-    account.set_block_id(BlockId::Tag(BlockTag::PreConfirmed));
 
     // Deploy VRF account if not already deployed
     if !is_deployed(&provider, vrf_account_address).await? {

crates/cartridge/src/vrf/mod.rs

@@ -10,13 +10,12 @@ mod client;
 pub mod bootstrap;
 pub mod sidecar;
 
-pub use client::*;
-
 pub use bootstrap::{
     bootstrap_vrf, derive_vrf_accounts, vrf_account_class_hash, vrf_consumer_class_hash,
     vrf_secret_key_from_account_key, VrfBootstrap, VrfBootstrapConfig, VrfBootstrapResult,
     VrfDerivedAccounts, BOOTSTRAP_TIMEOUT, VRF_ACCOUNT_SALT, VRF_CONSUMER_SALT,
 };
+pub use client::*;
 pub use sidecar::{
     resolve_executable, wait_for_http_ok, Error as VrfSidecarError, Result as VrfSidecarResult,
     VrfService, VrfServiceConfig, VrfServiceProcess, SIDECAR_TIMEOUT, VRF_SERVER_PORT,

crates/cartridge/src/vrf/sidecar.rs

@@ -2,25 +2,24 @@
 //!
 //! This module handles spawning and managing the VRF sidecar process.
 
-use std::env;
-use std::io;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::time::{Duration, Instant};
+use std::{env, io};
 
 use katana_primitives::{ContractAddress, Felt};
 use tokio::process::{Child, Command};
 use tokio::time::sleep;
 use tracing::{debug, info, warn};
 use url::Url;
 
-use super::bootstrap::{bootstrap_vrf, VrfBootstrapConfig, VrfBootstrapResult};
-
 const LOG_TARGET: &str = "katana::cartridge::vrf::sidecar";
 
 /// Fixed port used by vrf-server.
 pub const VRF_SERVER_PORT: u16 = 3000;
 
+const DEFAULT_VRF_SERVICE_PATH: &str = "vrf-service";
+
 /// Default timeout for waiting on sidecar readiness.
 pub const SIDECAR_TIMEOUT: Duration = Duration::from_secs(10);
 
@@ -47,91 +46,51 @@ pub enum Error {
     Bootstrap(#[source] anyhow::Error),
 }
 
-/// Result type alias for VRF sidecar operations.
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 // ============================================================================
-// Configuration Types
+// VRF Service
 // ============================================================================
 
-/// Configuration for the VRF service.
 #[derive(Debug, Clone)]
 pub struct VrfServiceConfig {
-    /// RPC URL of the katana node (for bootstrap).
-    pub rpc_url: Url,
-    /// Source account address (deploys contracts and funds VRF account).
-    pub source_address: ContractAddress,
-    /// Source account private key.
-    pub source_private_key: Felt,
-    /// Path to the vrf-server binary (None = lookup in PATH).
-    pub program_path: Option<PathBuf>,
+    pub vrf_account_address: ContractAddress,
+    pub vrf_private_key: Felt,
+    pub secret_key: u64,
 }
 
-// ============================================================================
-// VRF Service
-// ============================================================================
-
-/// VRF service that handles bootstrapping and spawning the sidecar process.
 #[derive(Debug, Clone)]
 pub struct VrfService {
     config: VrfServiceConfig,
-    bootstrap_result: Option<VrfBootstrapResult>,
+    path: PathBuf,
 }
 
 impl VrfService {
-    /// Create a new VRF service with the given configuration.
     pub fn new(config: VrfServiceConfig) -> Self {
-        Self { config, bootstrap_result: None }
+        Self { config, path: PathBuf::from(DEFAULT_VRF_SERVICE_PATH) }
     }
 
-    /// Set a pre-existing bootstrap result, skipping the bootstrap step.
+    /// Sets the path to the vrf service program.
     ///
-    /// Use this when the VRF contracts have already been deployed.
-    pub fn bootstrap_result(mut self, result: VrfBootstrapResult) -> Self {
-        self.bootstrap_result = Some(result);
+    /// If no path is set, the default executable name [`DEFAULT_VRF_SERVICE_PATH`] will be used.
+    pub fn path<T: Into<PathBuf>>(mut self, path: T) -> Self {
+        self.path = path.into();
         self
     }
 
-    /// Get the bootstrap result, if set.
-    pub fn get_bootstrap_result(&self) -> Option<&VrfBootstrapResult> {
-        self.bootstrap_result.as_ref()
-    }
-
-    /// Bootstrap the VRF service by deploying necessary contracts.
-    ///
-    /// This deploys the VRF account and consumer contracts via RPC,
-    /// sets up the VRF public key, and optionally funds the account.
-    pub async fn bootstrap(&mut self) -> Result<&VrfBootstrapResult> {
-        let bootstrap_config = VrfBootstrapConfig {
-            rpc_url: self.config.rpc_url.clone(),
-            source_address: self.config.source_address,
-            source_private_key: self.config.source_private_key,
-        };
-
-        let result = bootstrap_vrf(&bootstrap_config).await.map_err(Error::Bootstrap)?;
-        self.bootstrap_result = Some(result);
-
-        Ok(self.bootstrap_result.as_ref().expect("just set"))
-    }
-
-    /// Start the VRF sidecar process.
-    ///
-    /// This spawns the vrf-server binary and waits for it to become ready.
-    /// Returns an error if bootstrap has not been performed.
     pub async fn start(self) -> Result<VrfServiceProcess> {
-        let bootstrap_result = self.bootstrap_result.ok_or(Error::BootstrapResultNotSet)?.clone();
-
-        let bin = self.config.program_path.unwrap_or_else(|| "vrf-server".into());
-        let bin = resolve_executable(Path::new(&bin))?;
+        let bin = resolve_executable(&self.path)?;
 
         let mut command = Command::new(bin);
         command
             .arg("--port")
             .arg(VRF_SERVER_PORT.to_string())
             .arg("--account-address")
+            .arg(self.config.vrf_account_address.to_hex_string())
             .arg("--account-private-key")
+            .arg(self.config.vrf_private_key.to_hex_string())
             .arg("--secret-key")
-            .arg(bootstrap_result.secret_key.to_string())
+            .arg(self.config.secret_key.to_string())
             .stdout(Stdio::inherit())
             .stderr(Stdio::inherit())
             .kill_on_drop(true);
@@ -141,33 +100,26 @@ impl VrfService {
         let url = format!("http://127.0.0.1:{VRF_SERVER_PORT}/info",);
         wait_for_http_ok(&url, "vrf info", SIDECAR_TIMEOUT).await?;
 
-        Ok(VrfServiceProcess { process, bootstrap_result })
+        Ok(VrfServiceProcess { process, inner: self })
     }
 }
 
-// ============================================================================
-// VRF Sidecar Process
-// ============================================================================
-
 /// A running VRF sidecar process.
 #[derive(Debug)]
 pub struct VrfServiceProcess {
     process: Child,
-    bootstrap_result: VrfBootstrapResult,
+    inner: VrfService,
 }
 
 impl VrfServiceProcess {
-    /// Get a mutable reference to the underlying child process.
     pub fn process(&mut self) -> &mut Child {
         &mut self.process
     }
 
-    /// Get the bootstrap result containing VRF account information.
-    pub fn bootstrap_result(&self) -> &VrfBootstrapResult {
-        &self.bootstrap_result
+    pub fn config(&self) -> &VrfServiceConfig {
+        &self.inner.config
     }
 
-    /// Gracefully shutdown the sidecar process.
     pub async fn shutdown(&mut self) -> io::Result<()> {
         self.process.kill().await
     }

crates/cli/src/args.rs

@@ -36,8 +36,6 @@ use url::Url;
 
 use crate::file::NodeArgsConfig;
 use crate::options::*;
-#[cfg(feature = "cartridge")]
-use crate::sidecar::bootstrap_and_start_sidecars;
 #[cfg(feature = "vrf")]
 use crate::sidecar::{build_vrf_config, VrfSidecarInfo};
 use crate::utils::{self, parse_chain_config_dir, parse_seed};

crates/cli/src/sidecar.rs

@@ -286,8 +286,8 @@ pub async fn start_sidecars(
     //         .rpc(paymaster_cfg.rpc_url.clone())
     //         .port(paymaster_cfg.port)
     //         .api_key(paymaster_cfg.api_key.clone())
-    //         .relayer(paymaster_bootstrap.relayer_address, paymaster_bootstrap.relayer_private_key)
-    //         .gas_tank(
+    //         .relayer(paymaster_bootstrap.relayer_address,
+    // paymaster_bootstrap.relayer_private_key)         .gas_tank(
     //             paymaster_bootstrap.gas_tank_address,
     //             paymaster_bootstrap.gas_tank_private_key,
     //         )

crates/node/Cargo.toml

@@ -62,12 +62,12 @@ vrf = [
 	"katana-rpc-server/vrf",
 	"dep:stark-vrf",
 	"dep:ark-ff",
+	"cartridge",
 ]
 cartridge = [
 	"katana-rpc-api/cartridge",
 	"katana-rpc-server/cartridge",
 	"paymaster",
-	"vrf",
 ]
 explorer = ["katana-rpc-server/explorer"]
 native = ["katana-executor/native"]

crates/node/src/config/mod.rs

@@ -64,10 +64,6 @@ pub struct Config {
     #[cfg(feature = "paymaster")]
     pub paymaster: Option<paymaster::PaymasterConfig>,
 
-    /// VRF options.
-    #[cfg(feature = "vrf")]
-    pub vrf: Option<paymaster::VrfConfig>,
-
     /// TEE attestation options.
     #[cfg(feature = "tee")]
     pub tee: Option<tee::TeeConfig>,

crates/node/src/config/paymaster.rs

@@ -12,17 +12,6 @@ pub struct PaymasterConfig {
     pub cartridge_api: Option<CartridgeApiConfig>,
 }
 
-/// Configuration for connecting to a VRF service.
-///
-/// The node treats the VRF as an external service - it simply connects to the
-/// provided URL. Whether the service is managed externally or as a sidecar process
-/// is a concern of the CLI layer, not the node.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct VrfConfig {
-    /// The VRF service URL.
-    pub url: Url,
-}
-
 /// Configuration for connecting to a Cartridge paymaster service.
 ///
 /// The node treats the paymaster as an external service - it simply connects to the
@@ -40,4 +29,21 @@ pub struct CartridgeApiConfig {
     pub controller_deployer_address: ContractAddress,
     /// The paymaster account private key. (used for deploying controller)
     pub controller_deployer_private_key: Felt,
+
+    #[cfg(feature = "vrf")]
+    pub vrf: Option<VrfConfig>,
+}
+
+/// Configuration for connecting to a VRF service.
+///
+/// The node treats the VRF as an external service - it simply connects to the
+/// provided URL. Whether the service is managed externally or as a sidecar process
+/// is not a concern of the [`Node`](crate::Node).
+#[cfg(feature = "vrf")]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VrfConfig {
+    /// The VRF service URL.
+    pub url: Url,
+    /// The address of the VRF contract.
+    pub vrf_contract: ContractAddress,
 }

crates/node/src/lib.rs

@@ -232,42 +232,41 @@ where
                 );
 
                 #[cfg(feature = "vrf")]
-                let vrf = if let Some(vrf) = &config.vrf {
+                let vrf = if let Some(vrf) = &cartridge_api_cfg.vrf {
                     use url::Url;
 
-                    let derived = crate::sidecar::derive_vrf_accounts(vrf, &config, &backend)?;
                     let rpc_url = Url::parse(&format!("http://{}", config.rpc.socket_addr()))
                         .expect("valid rpc url");
 
                     Some(katana_rpc_server::cartridge::VrfServiceConfig {
                         rpc_url,
-                        url: vrf.url.clone(),
-                        account_address: derived.vrf_account_address,
+                        service_url: vrf.url.clone(),
+                        vrf_contract: vrf.vrf_contract,
                     })
                 } else {
                     None
                 };
 
-                #[cfg(not(feature = "vrf"))]
-                let vrf = None;
+                let cartridge_api_config = CartridgeConfig {
+                    paymaster_url: cfg.url.clone(),
+                    paymaster_api_key: cfg.api_key.clone(),
+                    api_url: cartridge_api_cfg.cartridge_api_url.clone(),
+                    controller_deployer_address: cartridge_api_cfg.controller_deployer_address,
+                    controller_deployer_private_key: cartridge_api_cfg
+                        .controller_deployer_private_key,
+                    #[cfg(feature = "vrf")]
+                    vrf,
+                };
 
-                let api = CartridgeApi::new(
+                let cartrige_api = CartridgeApi::new(
                     backend.clone(),
                     block_producer.clone(),
                     pool.clone(),
                     task_spawner.clone(),
-                    CartridgeConfig {
-                        paymaster_url: cfg.url.clone(),
-                        paymaster_api_key: cfg.api_key.clone(),
-                        api_url: cartridge_api_cfg.cartridge_api_url.clone(),
-                        controller_deployer_address: cartridge_api_cfg.controller_deployer_address,
-                        controller_deployer_private_key: cartridge_api_cfg
-                            .controller_deployer_private_key,
-                        vrf,
-                    },
+                    cartridge_api_config,
                 )?;
 
-                rpc_modules.merge(CartridgeApiServer::into_rpc(api))?;
+                rpc_modules.merge(CartridgeApiServer::into_rpc(cartrige_api))?;
 
                 Some(CartridgePaymasterConfig {
                     cartridge_api_url: cartridge_api_cfg.cartridge_api_url.clone(),

crates/rpc/rpc-server/src/cartridge/vrf.rs

@@ -11,9 +11,9 @@ use url::Url;
 
 #[derive(Debug, Clone)]
 pub struct VrfServiceConfig {
-    pub url: Url,
-    pub account_address: ContractAddress,
     pub rpc_url: Url,
+    pub service_url: Url,
+    pub vrf_contract: ContractAddress,
 }
 
 #[derive(Clone)]
@@ -26,8 +26,8 @@ pub struct VrfService {
 impl VrfService {
     pub fn new(config: VrfServiceConfig) -> Self {
         Self {
-            client: VrfClient::new(config.url),
-            account_address: config.account_address,
+            client: VrfClient::new(config.service_url),
+            account_address: config.vrf_contract,
             rpc_url: config.rpc_url,
         }
     }