wip

Author: kariy

Cargo.lock

@@ -88,17 +88,17 @@ pub struct VrfDerivedAccounts {
 /// This computes the deterministic VRF account address and VRF key pair
 /// from the source account's private key.
 pub fn derive_vrf_accounts(
-    source_address: ContractAddress,
-    source_private_key: Felt,
+    bootstrapper_address: ContractAddress,
+    bootstrapper_private_key: Felt,
 ) -> 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 secret_key = vrf_secret_key_from_account_key(bootstrapper_private_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)?;
 
     let account_public_key =
-        SigningKey::from_secret_scalar(source_private_key).verifying_key().scalar();
+        SigningKey::from_secret_scalar(bootstrapper_private_key).verifying_key().scalar();
     let vrf_account_class_hash = katana_contracts::vrf::CartridgeVrfAccount::HASH;
     // When using UDC with unique=0 (non-unique deployment), the deployer_address
     // used in address computation is 0, not the actual deployer or UDC address.
@@ -111,8 +111,8 @@ pub fn derive_vrf_accounts(
     .into();
 
     Ok(VrfDerivedAccounts {
-        source_address,
-        source_private_key,
+        source_address: bootstrapper_address,
+        source_private_key: bootstrapper_private_key,
         vrf_account_address,
         vrf_public_key_x,
         vrf_public_key_y,

crates/cartridge/src/vrf/bootstrap.rs

@@ -38,8 +38,6 @@ use url::Url;
 
 use crate::file::NodeArgsConfig;
 use crate::options::*;
-#[cfg(feature = "vrf")]
-use crate::sidecar::build_vrf_config;
 use crate::utils::{self, parse_chain_config_dir, parse_seed};
 
 pub(crate) const LOG_TARGET: &str = "katana::cli";
@@ -554,7 +552,7 @@ impl SequencerNodeArgs {
         #[cfg(feature = "cartridge")]
         if self.paymaster.cartridge_paymaster {
             #[cfg(feature = "vrf")]
-            let vrf = self.vrf_config()?;
+            let vrf = self.vrf_config(chain_spec)?;
 
             use anyhow::anyhow;
             use katana_genesis::allocation::GenesisAccountAlloc;
@@ -589,8 +587,32 @@ impl SequencerNodeArgs {
     }
 
     #[cfg(feature = "vrf")]
-    fn vrf_config(&self) -> Result<Option<VrfConfig>> {
-        build_vrf_config(&self.paymaster.vrf)
+    fn vrf_config(&self, chain: &ChainSpec) -> Result<Option<VrfConfig>> {
+        let options = &self.paymaster.vrf;
+
+        if !options.enabled {
+            return Ok(None);
+        }
+
+        if options.is_external() {
+            let url = options.url.clone().expect("must be set if external");
+            let vrf_account = options.vrf_account_contract.expect("must be set if external");
+
+            Ok(Some(VrfConfig { url, vrf_account }))
+        } else {
+            use cartridge::derive_vrf_accounts;
+
+            use crate::sidecar::prefunded_account;
+
+            let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
+            let addr = listener.local_addr()?;
+            let url = Url::parse(&format!("http://{addr}"))?;
+
+            let (account_address, pk) = prefunded_account(chain, 0)?;
+            let derived_result = derive_vrf_accounts(account_address, pk)?;
+
+            Ok(Some(VrfConfig { url, vrf_account: derived_result.vrf_account_address }))
+        }
     }
 
     #[cfg(feature = "tee")]
@@ -1069,58 +1091,4 @@ explorer = true
         assert!(config.chain.genesis().classes.get(&ControllerV109::HASH).is_none());
         assert!(config.chain.genesis().classes.get(&ControllerLatest::HASH).is_none());
     }
-
-    #[cfg(feature = "cartridge")]
-    #[test]
-    fn vrf_mode_adds_classes() {
-        use katana_primitives::utils::class::parse_sierra_class;
-
-        let args = SequencerNodeArgs::parse_from(["katana", "--paymaster", "--vrf"]);
-        let result = args.config().unwrap();
-        let config = &result;
-
-        let vrf_account_class = parse_sierra_class(include_str!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/../controller/classes/cartridge_vrf_VrfAccount.contract_class.json"
-        )))
-        .unwrap();
-        let vrf_account_hash = vrf_account_class.class_hash().unwrap();
-
-        let vrf_consumer_class = parse_sierra_class(include_str!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/../controller/classes/cartridge_vrf_VrfConsumer.contract_class.json"
-        )))
-        .unwrap();
-        let vrf_consumer_hash = vrf_consumer_class.class_hash().unwrap();
-
-        assert!(config.chain.genesis().classes.get(&vrf_account_hash).is_some());
-        assert!(config.chain.genesis().classes.get(&vrf_consumer_hash).is_some());
-    }
-
-    #[cfg(feature = "paymaster")]
-    #[test]
-    fn paymaster_adds_forwarder_class() {
-        use katana_primitives::utils::class::parse_sierra_class;
-
-        let args = SequencerNodeArgs::parse_from(["katana", "--paymaster"]);
-        let result = args.config().unwrap();
-        let config = &result;
-
-        let forwarder_class = parse_sierra_class(include_str!(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/../controller/classes/avnu_Forwarder.contract_class.json"
-        )))
-        .unwrap();
-        let forwarder_hash = forwarder_class.class_hash().unwrap();
-
-        assert!(config.chain.genesis().classes.get(&forwarder_hash).is_some());
-    }
-
-    #[cfg(feature = "vrf")]
-    #[test]
-    fn vrf_requires_paymaster() {
-        let args = SequencerNodeArgs::parse_from(["katana", "--vrf"]);
-        let err = args.config().unwrap_err();
-        assert!(err.to_string().contains("--vrf requires paymaster"));
-    }
 }

crates/cli/src/args.rs

@@ -9,8 +9,6 @@ pub use cartridge::vrf::{
 use katana_chain_spec::ChainSpec;
 use katana_genesis::allocation::GenesisAccountAlloc;
 use katana_genesis::constant::{DEFAULT_ETH_FEE_TOKEN_ADDRESS, DEFAULT_STRK_FEE_TOKEN_ADDRESS};
-#[cfg(feature = "vrf")]
-use katana_node::config::paymaster::VrfConfig;
 pub use katana_paymaster::{
     format_felt, wait_for_paymaster_ready, PaymasterService, PaymasterServiceConfig,
     PaymasterServiceConfigBuilder, PaymasterSidecarProcess,
@@ -25,28 +23,6 @@ use crate::options::VrfOptions;
 /// Default API key for the paymaster sidecar.
 pub const DEFAULT_PAYMASTER_API_KEY: &str = "paymaster_katana";
 
-#[cfg(feature = "vrf")]
-pub fn build_vrf_config(options: &VrfOptions) -> Result<Option<VrfConfig>> {
-    if !options.enabled {
-        return Ok(None);
-    }
-
-    if options.is_external() {
-        let url = options.url.clone().expect("must be set if external");
-        let vrf_account = options.vrf_account_contract.expect("must be set if external");
-
-        Ok(Some(VrfConfig { url, vrf_account }))
-    } else {
-        let listener = std::net::TcpListener::bind("127.0.0.1:0")?;
-        let addr = listener.local_addr()?;
-        let url = Url::parse(&format!("http://{addr}"))?;
-
-        todo!("infer vrf contract address")
-
-        // Ok(Some(VrfConfig { url }))
-    }
-}
-
 pub async fn bootstrap_paymaster(
     options: &PaymasterOptions,
     paymaster_url: Url,
@@ -101,7 +77,7 @@ pub async fn bootstrap_vrf(
     Ok(vrf_service)
 }
 
-fn prefunded_account(chain_spec: &ChainSpec, index: u16) -> Result<(ContractAddress, Felt)> {
+pub fn prefunded_account(chain_spec: &ChainSpec, index: u16) -> Result<(ContractAddress, Felt)> {
     let (address, allocation) = chain_spec
         .genesis()
         .accounts()

crates/cli/src/sidecar.rs

@@ -21,7 +21,6 @@ katana-pool.workspace = true
 katana-pool-api.workspace = true
 katana-primitives.workspace = true
 katana-provider.workspace = true
-katana-genesis = { workspace = true, optional = true }
 katana-rpc-server.workspace = true
 katana-rpc-api.workspace = true
 katana-rpc-client.workspace = true
@@ -41,27 +40,19 @@ parking_lot.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 url.workspace = true
-ark-ff = { version = "0.4.2", optional = true }
 
 strum.workspace = true
 strum_macros.workspace = true
 
-stark-vrf = { workspace = true, optional = true }
-starknet = { workspace = true, optional = true }
-
 tokio = { workspace = true, features = [ "time" ] }
 
 [features]
 paymaster = [
-	"dep:katana-genesis",
-	"dep:starknet",
 	"katana-rpc-api/paymaster",
 	"katana-rpc-server/paymaster",
 ]
 vrf = [
 	"katana-rpc-server/vrf",
-	"dep:stark-vrf",
-	"dep:ark-ff",
 	"cartridge",
 ]
 cartridge = [

crates/node/Cargo.toml

@@ -4,8 +4,6 @@ pub mod full;
 
 pub mod config;
 pub mod exit;
-#[cfg(feature = "vrf")]
-pub mod sidecar;
 
 use std::future::IntoFuture;
 use std::sync::Arc;