wip

Author: kariy

crates/cartridge/src/vrf/bootstrap.rs

@@ -7,7 +7,6 @@
 //!
 //! This module uses the starknet crate's account abstraction for transaction handling.
 
-use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
@@ -123,28 +122,31 @@ pub fn derive_vrf_accounts(
     })
 }
 
-pub async fn bootstrap_vrf(rpc_addr: SocketAddr, chain: &ChainSpec) -> Result<VrfBootstrapResult> {
-    let rpc_url = Url::parse(&format!("http://{rpc_addr}"))?;
+pub async fn bootstrap_vrf(
+    rpc_url: Url,
+    bootstrapper_account_address: ContractAddress,
+    bootstrapper_account_private_key: Felt,
+) -> Result<VrfBootstrapResult> {
     let provider = Arc::new(JsonRpcClient::new(HttpTransport::new(rpc_url.clone())));
 
-    let bootstrapper_account = prefunded_account(chain, 0)?;
-
     // Get chain ID from the node
     let chain_id_felt = provider.chain_id().await.context("failed to get chain ID from node")?;
     let chain_id = ChainId::Id(chain_id_felt);
 
-    let derived = derive_vrf_accounts(bootstrapper_account.0, bootstrapper_account.1)?;
+    let derived =
+        derive_vrf_accounts(bootstrapper_account_address, bootstrapper_account_private_key)?;
     let vrf_account_address = derived.vrf_account_address;
     let account_public_key =
-        SigningKey::from_secret_scalar(bootstrapper_account.1).verifying_key().scalar();
+        SigningKey::from_secret_scalar(bootstrapper_account_private_key).verifying_key().scalar();
     let vrf_account_class_hash = vrf_account_class_hash()?;
 
     // Create the source account for transactions
-    let signer = LocalWallet::from(SigningKey::from_secret_scalar(bootstrapper_account.1));
+    let signer =
+        LocalWallet::from(SigningKey::from_secret_scalar(bootstrapper_account_private_key));
     let account = SingleOwnerAccount::new(
         provider.clone(),
         signer,
-        bootstrapper_account.0.into(),
+        bootstrapper_account_address.into(),
         chain_id_felt,
         ExecutionEncoding::New,
     );
@@ -180,7 +182,8 @@ pub async fn bootstrap_vrf(rpc_addr: SocketAddr, chain: &ChainSpec) -> Result<Vr
 
     // Set VRF public key on the deployed account
     // Create account for the VRF account to call set_vrf_public_key on itself
-    let vrf_signer = LocalWallet::from(SigningKey::from_secret_scalar(bootstrapper_account.1));
+    let vrf_signer =
+        LocalWallet::from(SigningKey::from_secret_scalar(bootstrapper_account_private_key));
     let mut vrf_account = SingleOwnerAccount::new(
         provider.clone(),
         vrf_signer,
@@ -232,7 +235,7 @@ pub async fn bootstrap_vrf(rpc_addr: SocketAddr, chain: &ChainSpec) -> Result<Vr
         chain_id,
         vrf_account_address,
         // right now, we take the bootstrapper account private key as the vrf account's private key
-        vrf_account_private_key: bootstrapper_account.1,
+        vrf_account_private_key: bootstrapper_account_private_key,
     })
 }
 
@@ -309,21 +312,6 @@ fn felt_from_field<T: std::fmt::Display>(value: T) -> Result<Felt> {
     Felt::from_dec_str(&decimal).map_err(|err| anyhow!("invalid field value: {err}"))
 }
 
-fn prefunded_account(chain_spec: &ChainSpec, index: u16) -> Result<(ContractAddress, Felt)> {
-    let (address, allocation) = chain_spec
-        .genesis()
-        .accounts()
-        .nth(index as usize)
-        .ok_or_else(|| anyhow!("prefunded account index {} out of range", index))?;
-
-    let private_key = match allocation {
-        GenesisAccountAlloc::DevAccount(account) => account.private_key,
-        _ => return Err(anyhow!("prefunded account {} has no private key", address)),
-    };
-
-    Ok((*address, private_key))
-}
-
 #[cfg(test)]
 mod tests {
     use katana_primitives::Felt;

crates/cli/src/args.rs

@@ -139,10 +139,6 @@ pub struct SequencerNodeArgs {
     #[command(flatten)]
     pub paymaster: PaymasterOptions,
 
-    #[cfg(feature = "vrf")]
-    #[command(flatten)]
-    pub vrf: VrfOptions,
-
     #[cfg(feature = "tee")]
     #[command(flatten)]
     pub tee: TeeOptions,
@@ -217,26 +213,21 @@ impl SequencerNodeArgs {
             };
 
             #[cfg(feature = "vrf")]
-            let mut vrf = if self.vrf.is_external() {
+            let mut vrf = if self.paymaster.vrf.is_external() {
                 None
             } else {
-                use cartridge::{VrfService, VrfServiceConfig};
+                use crate::sidecar::bootstrap_vrf;
 
-                let result = cartridge::bootstrap_vrf(
+                let vrf = bootstrap_vrf(
+                    &self.paymaster.vrf,
                     handle.rpc().addr().clone(),
                     &handle.node().config().chain,
                 )
-                .await?;
-
-                let vrf_process = VrfService::new(VrfServiceConfig {
-                    secret_key: result.secret_key,
-                    vrf_account_address: result.vrf_account_address,
-                    vrf_private_key: result.vrf_account_private_key,
-                })
+                .await?
                 .start()
                 .await?;
 
-                Some(vrf_process)
+                Some(vrf)
             };
 
             // Wait until an OS signal (ie SIGINT, SIGTERM) is received or the node is shutdown.
@@ -279,14 +270,6 @@ impl SequencerNodeArgs {
         #[cfg(feature = "paymaster")]
         let paymaster = self.paymaster_config(&chain)?;
 
-        #[cfg(feature = "vrf")]
-        let vrf = self.vrf_config()?;
-
-        #[cfg(all(feature = "vrf", feature = "cartridge"))]
-        if vrf.is_some() && paymaster.is_none() {
-            return Err(anyhow::anyhow!("--vrf requires paymaster; enable --paymaster"));
-        }
-
         // the `katana init` will automatically generate a messaging config. so if katana is run
         // with `--chain` then the `--messaging` flag is not required. this is temporary and
         // the messagign config will eventually be removed slowly.
@@ -351,7 +334,7 @@ impl SequencerNodeArgs {
             // We put it here so that even when the individual api are explicitly specified
             // (ie `--rpc.api`) we guarantee that the cartridge rpc is enabled.
             #[cfg(feature = "cartridge")]
-            if self.paymaster.enabled || self.vrf.enabled {
+            if self.paymaster.enabled || self.paymaster.vrf.enabled {
                 modules.add(RpcModuleKind::Cartridge);
             }
 
@@ -431,7 +414,7 @@ impl SequencerNodeArgs {
             }
 
             #[cfg(feature = "vrf")]
-            if self.vrf.enabled {
+            if self.paymaster.vrf.enabled {
                 katana_slot_controller::add_vrf_account_class(&mut chain_spec.genesis);
                 katana_slot_controller::add_vrf_consumer_class(&mut chain_spec.genesis);
             }
@@ -607,7 +590,7 @@ impl SequencerNodeArgs {
 
     #[cfg(feature = "vrf")]
     fn vrf_config(&self) -> Result<Option<VrfConfig>> {
-        build_vrf_config(&self.vrf)
+        build_vrf_config(&self.paymaster.vrf)
     }
 
     #[cfg(feature = "tee")]
@@ -686,11 +669,6 @@ impl SequencerNodeArgs {
             self.paymaster.merge(config.paymaster.as_ref());
         }
 
-        #[cfg(feature = "vrf")]
-        {
-            self.vrf.merge(config.vrf.as_ref());
-        }
-
         #[cfg(feature = "explorer")]
         {
             if !self.explorer.explorer {

crates/cli/src/file.rs

@@ -30,8 +30,6 @@ pub struct NodeArgsConfig {
     pub cartridge: Option<CartridgeOptions>,
     #[cfg(feature = "paymaster")]
     pub paymaster: Option<PaymasterOptions>,
-    #[cfg(feature = "vrf")]
-    pub vrf: Option<VrfOptions>,
     #[cfg(feature = "explorer")]
     pub explorer: Option<ExplorerOptions>,
 }
@@ -98,11 +96,6 @@ impl TryFrom<SequencerNodeArgs> for NodeArgsConfig {
             };
         }
 
-        #[cfg(feature = "vrf")]
-        {
-            node_config.vrf = if args.vrf == VrfOptions::default() { None } else { Some(args.vrf) };
-        }
-
         #[cfg(feature = "explorer")]
         {
             node_config.explorer = if args.explorer == ExplorerOptions::default() {

crates/cli/src/options.rs

@@ -608,6 +608,10 @@ pub struct PaymasterOptions {
     #[arg(requires_all = ["paymaster_enabled", "cartridge_paymaster"])]
     #[serde(default = "default_api_url")]
     pub cartridge_api: Url,
+
+    #[cfg(feature = "vrf")]
+    #[command(flatten)]
+    pub vrf: VrfOptions,
 }
 
 #[cfg(feature = "paymaster")]
@@ -638,6 +642,10 @@ impl PaymasterOptions {
             if self.bin.is_none() {
                 self.bin = other.bin.clone();
             }
+
+            if self.vrf == VrfOptions::default() {
+                self.vrf = other.vrf.clone();
+            }
         }
     }
 }
@@ -650,7 +658,10 @@ pub struct VrfOptions {
     ///
     /// By default, the VRF runs as a sidecar process. If `--vrf.url` is provided,
     /// it will connect to an external VRF service instead.
+    ///
+    /// Requires the Cartridge paymaster to be enabled i.e., `--paymaster.cartridge`.
     #[arg(long = "vrf", id = "vrf_enabled")]
+    #[arg(requires = "cartridge_paymaster")]
     #[serde(default)]
     pub enabled: bool,
 
@@ -730,6 +741,8 @@ impl Default for PaymasterOptions {
             price_api_key: None,
             cartridge_paymaster: false,
             cartridge_api: default_api_url(),
+            #[cfg(feature = "vrf")]
+            vrf: VrfOptions::default(),
         }
     }
 }