feat(testing): integrate dummy snark worker

binier · binier · commit b043f82abf38 · 2024-01-30T11:28:17.000+04:00
closes: #206
diff --git a/ledger/src/scan_state/conv.rs b/ledger/src/scan_state/conv.rs
@@ -616,11 +616,17 @@ impl From<&Statement<SokDigest>> for MinaStateSnarkedLedgerStateWithSokStableV2
             .into(),
             supply_increase: (&value.supply_increase).into(),
             fee_excess: (&value.fee_excess).into(),
-            sok_digest: MinaBaseZkappAccountZkappUriStableV1(value.sok_digest.as_slice().into()),
+            sok_digest: (&value.sok_digest).into(),
         }
     }
 }
 
+impl From<&SokDigest> for MinaBaseZkappAccountZkappUriStableV1 {
+    fn from(value: &SokDigest) -> Self {
+        Self(value.as_slice().into())
+    }
+}
+
 impl From<&MinaBaseTransactionStatusStableV2> for TransactionStatus {
     fn from(value: &MinaBaseTransactionStatusStableV2) -> Self {
         match value {
diff --git a/node/src/account/public_key.rs b/node/src/account/public_key.rs
@@ -35,6 +35,15 @@ impl From<CompressedPubKey> for AccountPublicKey {
     }
 }
 
+impl From<AccountPublicKey> for CompressedPubKey {
+    fn from(value: AccountPublicKey) -> Self {
+        Self {
+            is_odd: value.0.is_odd,
+            x: value.0.into_inner().x.into(),
+        }
+    }
+}
+
 impl From<NonZeroCurvePoint> for AccountPublicKey {
     fn from(value: NonZeroCurvePoint) -> Self {
         Self(value)
diff --git a/node/testing/src/cluster/mod.rs b/node/testing/src/cluster/mod.rs
@@ -191,7 +191,7 @@ impl Cluster {
             },
             global: GlobalConfig {
                 build: BuildEnv::get().into(),
-                snarker: None,
+                snarker: testing_config.snark_worker,
             },
             p2p: P2pConfig {
                 libp2p_port: Some(libp2p_port),
diff --git a/node/testing/src/main.rs b/node/testing/src/main.rs
@@ -87,13 +87,15 @@ impl Command {
                                 .into_iter()
                                 .find(|s| <&'static str>::from(s) == name)
                             {
-                                scenario.run_and_save_from_scratch(config).await;
+                                scenario.run_only_from_scratch(config).await;
+                                // scenario.run_and_save_from_scratch(config).await;
                             } else {
                                 anyhow::bail!("no such scenario: \"{name}\"");
                             }
                         } else {
                             for scenario in Scenarios::iter() {
-                                scenario.run_and_save_from_scratch(config.clone()).await;
+                                scenario.run_only_from_scratch(config.clone()).await;
+                                // scenario.run_and_save_from_scratch(config.clone()).await;
                             }
                         }
                         Ok(())
diff --git a/node/testing/src/node/rust/config.rs b/node/testing/src/node/rust/config.rs
@@ -1,6 +1,6 @@
 use std::time::Duration;
 
-use node::{account::AccountSecretKey, BlockProducerConfig};
+use node::{account::AccountSecretKey, BlockProducerConfig, SnarkerConfig};
 use serde::{Deserialize, Serialize};
 
 use crate::scenario::ListenerNode;
@@ -24,6 +24,7 @@ pub struct RustNodeTestingConfig {
     pub ask_initial_peers_interval: Duration,
     pub initial_peers: Vec<ListenerNode>,
     pub peer_id: TestPeerId,
+    pub snark_worker: Option<SnarkerConfig>,
     pub block_producer: Option<RustNodeBlockProducerTestingConfig>,
 }
 
@@ -43,6 +44,7 @@ impl RustNodeTestingConfig {
             initial_peers: Vec::new(),
             peer_id: TestPeerId::default(),
             block_producer: None,
+            snark_worker: None,
         }
     }
 
diff --git a/node/testing/src/scenarios/cluster_runner.rs b/node/testing/src/scenarios/cluster_runner.rs
@@ -3,6 +3,7 @@ use std::{
     time::Duration,
 };
 
+use ledger::BaseLedger;
 use node::{
     account::{AccountPublicKey, AccountSecretKey},
     event_source::Event,
@@ -338,7 +339,7 @@ impl<'a> ClusterRunner<'a> {
         self.cluster.debugger()
     }
 
-    /// Block producer accounts, ordered by total stake, smallest first.
+    /// Block producer accounts, ordered by total stake, largest first.
     ///
     /// Warning: caller must ensure we are using custom daemon json if
     /// this method is called, so that we have secret keys for
@@ -373,9 +374,36 @@ impl<'a> ClusterRunner<'a> {
             .collect::<Vec<_>>();
 
         // order by stake
-        block_producers.sort_by(|(_, s1), (_, s2)| s1.cmp(s2));
+        block_producers.sort_by(|(_, s1), (_, s2)| s2.cmp(s1));
         block_producers
     }
+
+    pub fn accounts_with_sec_keys<'b>(
+        &'b self,
+        node_id: ClusterNodeId,
+    ) -> Box<dyn 'b + Iterator<Item = (AccountSecretKey, Box<ledger::Account>)>> {
+        let Some(mask) = self.node(node_id).and_then(|node| {
+            let best_tip = node.state().transition_frontier.best_tip()?;
+            let ledger_hash = best_tip.staged_ledger_hash();
+            let (mask, _) = LedgerService::ctx(node.service()).mask(ledger_hash)?;
+            Some(mask)
+        }) else {
+            return Box::new(std::iter::empty());
+        };
+
+        let depth = mask.depth() as usize;
+        let num_accounts = mask.num_accounts() as u64;
+        Box::new(
+            (0..num_accounts)
+                .map(ledger::AccountIndex)
+                .filter_map(move |index| mask.get(ledger::Address::from_index(index, depth)))
+                .filter_map(|account| {
+                    let pub_key = account.public_key.clone().into();
+                    let sec_key = self.get_account_sec_key(&pub_key)?;
+                    Some((sec_key.clone(), account))
+                }),
+        )
+    }
 }
 
 impl RunDecision {
diff --git a/node/testing/src/scenarios/simulation/small.rs b/node/testing/src/scenarios/simulation/small.rs
@@ -23,7 +23,9 @@ impl SimulationSmall {
             daemon_json: DaemonJsonGenConfig::Counts { whales: 2, fish: 4 },
             seed_nodes: 2,
             normal_nodes: 2,
-            run_until: SimulatorRunUntil::Epoch(8),
+            snark_workers: 1,
+            block_producers: 6,
+            run_until: SimulatorRunUntil::Epoch(3),
             run_until_timeout: Duration::from_secs(30 * 60),
         });
         simulator.run(runner).await;
diff --git a/node/testing/src/scenarios/solo_node/sync_to_genesis.rs b/node/testing/src/scenarios/solo_node/sync_to_genesis.rs
@@ -50,6 +50,7 @@ impl SoloNodeSyncToGenesis {
             ask_initial_peers_interval: Duration::from_secs(60 * 60),
             initial_peers: Vec::new(),
             peer_id: Default::default(),
+            snark_worker: None,
             block_producer: None,
         });
 
diff --git a/node/testing/src/service/mod.rs b/node/testing/src/service/mod.rs
@@ -3,19 +3,28 @@ mod rpc_service;
 use std::time::Duration;
 use std::{collections::BTreeMap, ffi::OsStr, sync::Arc};
 
+use ledger::dummy::dummy_transaction_proof;
+use ledger::scan_state::scan_state::transaction_snark::SokMessage;
 use ledger::Mask;
-use mina_p2p_messages::v2::{CurrencyFeeStableV1, LedgerHash, NonZeroCurvePoint};
+use mina_p2p_messages::v2::{
+    CurrencyFeeStableV1, LedgerHash, LedgerProofProdStableV2, MinaBaseZkappAccountZkappUriStableV1,
+    MinaStateSnarkedLedgerStateWithSokStableV2, NonZeroCurvePoint,
+    SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponseA0Single, TransactionSnarkStableV2,
+    TransactionSnarkWorkTStableV2Proofs,
+};
+use node::account::AccountPublicKey;
 use node::block_producer::vrf_evaluator::VrfEvaluatorInput;
 use node::core::channels::mpsc;
 use node::core::requests::{PendingRequests, RequestId};
 use node::core::snark::{Snark, SnarkJobId};
+use node::external_snark_worker::ExternalSnarkWorkerEvent;
 use node::recorder::Recorder;
 use node::service::BlockProducerVrfEvaluatorService;
 use node::snark::block_verify::{
     SnarkBlockVerifyId, SnarkBlockVerifyService, VerifiableBlockWithHash,
 };
 use node::snark::work_verify::{SnarkWorkVerifyId, SnarkWorkVerifyService};
-use node::snark::{VerifierIndex, VerifierSRS};
+use node::snark::{SnarkEvent, VerifierIndex, VerifierSRS};
 use node::snark_pool::{JobState, SnarkPoolService};
 use node::stats::Stats;
 use node::{
@@ -61,6 +70,8 @@ pub struct NodeTestingService {
     /// Events sent by the real service not yet received by state machine.
     pending_events: PendingRequests<PendingEventIdType, Event>,
     dyn_effects: Option<DynEffects>,
+
+    snarker_sok_digest: Option<MinaBaseZkappAccountZkappUriStableV1>,
     /// Once dropped, it will cause all threads associated to shutdown.
     _shutdown: mpsc::Receiver<()>,
 }
@@ -75,6 +86,7 @@ impl NodeTestingService {
             monotonic_time: Instant::now(),
             pending_events: PendingRequests::new(),
             dyn_effects: None,
+            snarker_sok_digest: None,
             _shutdown,
         }
     }
@@ -117,6 +129,10 @@ impl NodeTestingService {
         self.dyn_effects.take()
     }
 
+    pub fn set_snarker_sok_digest(&mut self, digest: MinaBaseZkappAccountZkappUriStableV1) {
+        self.snarker_sok_digest = Some(digest);
+    }
+
     pub fn pending_events(&mut self) -> impl Iterator<Item = (PendingEventId, &Event)> {
         while let Ok(req) = self.real.rpc.req_receiver().try_recv() {
             self.real.process_rpc_request(req);
@@ -278,13 +294,18 @@ impl SnarkBlockVerifyService for NodeTestingService {
         verifier_srs: Arc<VerifierSRS>,
         block: VerifiableBlockWithHash,
     ) {
-        SnarkBlockVerifyService::verify_init(
-            &mut self.real,
-            req_id,
-            verifier_index,
-            verifier_srs,
-            block,
-        )
+        let _ = (verifier_index, verifier_srs, block);
+        let _ = self
+            .real
+            .event_sender
+            .send(SnarkEvent::BlockVerify(req_id, Ok(())).into());
+        // SnarkBlockVerifyService::verify_init(
+        //     &mut self.real,
+        //     req_id,
+        //     verifier_index,
+        //     verifier_srs,
+        //     block,
+        // )
     }
 }
 
@@ -296,13 +317,18 @@ impl SnarkWorkVerifyService for NodeTestingService {
         verifier_srs: Arc<VerifierSRS>,
         work: Vec<Snark>,
     ) {
-        SnarkWorkVerifyService::verify_init(
-            &mut self.real,
-            req_id,
-            verifier_index,
-            verifier_srs,
-            work,
-        )
+        let _ = (verifier_index, verifier_srs, work);
+        let _ = self
+            .real
+            .event_sender
+            .send(SnarkEvent::WorkVerify(req_id, Ok(())).into());
+        // SnarkWorkVerifyService::verify_init(
+        //     &mut self.real,
+        //     req_id,
+        //     verifier_index,
+        //     verifier_srs,
+        //     work,
+        // )
     }
 }
 
@@ -329,22 +355,74 @@ impl ExternalSnarkWorkerService for NodeTestingService {
         public_key: NonZeroCurvePoint,
         fee: CurrencyFeeStableV1,
     ) -> Result<(), node::external_snark_worker::ExternalSnarkWorkerError> {
-        self.real.start(path, public_key, fee)
+        let _ = path;
+
+        let pub_key = AccountPublicKey::from(public_key);
+        let sok_message = SokMessage::create((&fee).into(), pub_key.into());
+        self.set_snarker_sok_digest((&sok_message.digest()).into());
+        let _ = self
+            .real
+            .event_sender
+            .send(ExternalSnarkWorkerEvent::Started.into());
+        Ok(())
+        // self.real.start(path, public_key, fee)
     }
 
     fn submit(
         &mut self,
         spec: SnarkWorkSpec,
     ) -> Result<(), node::external_snark_worker::ExternalSnarkWorkerError> {
-        self.real.submit(spec)
+        let sok_digest = self.snarker_sok_digest.clone().unwrap();
+        let make_dummy_proof = |spec| {
+            let statement = match spec {
+                SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponseA0Single::Transition(v, _) => v.0,
+                SnarkWorkerWorkerRpcsVersionedGetWorkV2TResponseA0Single::Merge(v) => v.0 .0,
+            };
+
+            LedgerProofProdStableV2(TransactionSnarkStableV2 {
+                statement: MinaStateSnarkedLedgerStateWithSokStableV2 {
+                    source: statement.source,
+                    target: statement.target,
+                    connecting_ledger_left: statement.connecting_ledger_left,
+                    connecting_ledger_right: statement.connecting_ledger_right,
+                    supply_increase: statement.supply_increase,
+                    fee_excess: statement.fee_excess,
+                    sok_digest: sok_digest.clone(),
+                },
+                proof: (*dummy_transaction_proof()).clone(),
+            })
+        };
+        let res = match spec {
+            SnarkWorkSpec::One(v) => TransactionSnarkWorkTStableV2Proofs::One(make_dummy_proof(v)),
+            SnarkWorkSpec::Two((v1, v2)) => TransactionSnarkWorkTStableV2Proofs::Two((
+                make_dummy_proof(v1),
+                make_dummy_proof(v2),
+            )),
+        };
+        let _ = self
+            .real
+            .event_sender
+            .send(ExternalSnarkWorkerEvent::WorkResult(Arc::new(res)).into());
+        Ok(())
+        // self.real.submit(spec)
     }
 
     fn cancel(&mut self) -> Result<(), node::external_snark_worker::ExternalSnarkWorkerError> {
-        self.real.cancel()
+        let _ = self
+            .real
+            .event_sender
+            .send(ExternalSnarkWorkerEvent::WorkCancelled.into());
+        Ok(())
+        // self.real.cancel()
     }
 
     fn kill(&mut self) -> Result<(), node::external_snark_worker::ExternalSnarkWorkerError> {
-        self.real.kill()
+        let _ = self
+            .real
+            .event_sender
+            .send(ExternalSnarkWorkerEvent::Killed.into());
+        Ok(())
+        // self.real.kill()
     }
 }
 
diff --git a/node/testing/src/simulator/config.rs b/node/testing/src/simulator/config.rs
@@ -9,6 +9,8 @@ pub struct SimulatorConfig {
     pub daemon_json: DaemonJsonGenConfig,
     pub seed_nodes: usize,
     pub normal_nodes: usize,
+    pub snark_workers: usize,
+    pub block_producers: usize,
     pub run_until: SimulatorRunUntil,
     pub run_until_timeout: Duration,
 }
diff --git a/node/testing/src/simulator/mod.rs b/node/testing/src/simulator/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -616,11 +616,17 @@ impl From<&Statement<SokDigest>> for MinaStateSnarkedLedgerStateWithSokStableV2`
`616`	`616`	`.into(),`
`617`	`617`	`supply_increase: (&value.supply_increase).into(),`
`618`	`618`	`fee_excess: (&value.fee_excess).into(),`
`619`		`- sok_digest: MinaBaseZkappAccountZkappUriStableV1(value.sok_digest.as_slice().into()),`
	`619`	`+ sok_digest: (&value.sok_digest).into(),`
`620`	`620`	`}`
`621`	`621`	`}`
`622`	`622`	`}`
`623`	`623`
	`624`	`+impl From<&SokDigest> for MinaBaseZkappAccountZkappUriStableV1 {`
	`625`	`+ fn from(value: &SokDigest) -> Self {`
	`626`	`+ Self(value.as_slice().into())`
	`627`	`+ }`
	`628`	`+}`
	`629`	`+`
`624`	`630`	`impl From<&MinaBaseTransactionStatusStableV2> for TransactionStatus {`
`625`	`631`	`fn from(value: &MinaBaseTransactionStatusStableV2) -> Self {`
`626`	`632`	`match value {`
Original file line number	Diff line number	Diff line change
`@@ -87,13 +87,15 @@ impl Command {`
`87`	`87`	`.into_iter()`
`88`	`88`	`.find(\|s\| <&'static str>::from(s) == name)`
`89`	`89`	`{`
`90`		`- scenario.run_and_save_from_scratch(config).await;`
	`90`	`+ scenario.run_only_from_scratch(config).await;`
	`91`	`+ // scenario.run_and_save_from_scratch(config).await;`
`91`	`92`	`} else {`
`92`	`93`	`anyhow::bail!("no such scenario: \"{name}\"");`
`93`	`94`	`}`
`94`	`95`	`} else {`
`95`	`96`	`for scenario in Scenarios::iter() {`
`96`		`- scenario.run_and_save_from_scratch(config.clone()).await;`
	`97`	`+ scenario.run_only_from_scratch(config.clone()).await;`
	`98`	`+ // scenario.run_and_save_from_scratch(config.clone()).await;`
`97`	`99`	`}`
`98`	`100`	`}`
`99`	`101`	`Ok(())`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use std::time::Duration;`
`2`	`2`
`3`		`-use node::{account::AccountSecretKey, BlockProducerConfig};`
	`3`	`+use node::{account::AccountSecretKey, BlockProducerConfig, SnarkerConfig};`
`4`	`4`	`use serde::{Deserialize, Serialize};`
`5`	`5`
`6`	`6`	`use crate::scenario::ListenerNode;`
`@@ -24,6 +24,7 @@ pub struct RustNodeTestingConfig {`
`24`	`24`	`pub ask_initial_peers_interval: Duration,`
`25`	`25`	`pub initial_peers: Vec<ListenerNode>,`
`26`	`26`	`pub peer_id: TestPeerId,`
	`27`	`+ pub snark_worker: Option<SnarkerConfig>,`
`27`	`28`	`pub block_producer: Option<RustNodeBlockProducerTestingConfig>,`
`28`	`29`	`}`
`29`	`30`
`@@ -43,6 +44,7 @@ impl RustNodeTestingConfig {`
`43`	`44`	`initial_peers: Vec::new(),`
`44`	`45`	`peer_id: TestPeerId::default(),`
`45`	`46`	`block_producer: None,`
	`47`	`+ snark_worker: None,`
`46`	`48`	`}`
`47`	`49`	`}`
`48`	`50`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@ pub struct SimulatorConfig {`
`9`	`9`	`pub daemon_json: DaemonJsonGenConfig,`
`10`	`10`	`pub seed_nodes: usize,`
`11`	`11`	`pub normal_nodes: usize,`
	`12`	`+ pub snark_workers: usize,`
	`13`	`+ pub block_producers: usize,`
`12`	`14`	`pub run_until: SimulatorRunUntil,`
`13`	`15`	`pub run_until_timeout: Duration,`
`14`	`16`	`}`