feat(slasher): add stub contract

Author: Rexagon

cli/src/node/config.rs

@@ -10,6 +10,7 @@ use tycho_control::ControlServerConfig;
 use tycho_core::node::NodeBaseConfig;
 use tycho_crypto::ed25519;
 use tycho_rpc::RpcConfig;
+use tycho_slasher::SlasherConfig;
 use tycho_types::cell::HashBytes;
 use tycho_types::models::StdAddr;
 use tycho_util::cli::config::ThreadPoolConfig;
@@ -165,6 +166,9 @@ pub struct NodeConfig {
 
     pub validator: ValidatorStdImplConfig,
 
+    #[partial]
+    pub slasher: SlasherConfig,
+
     #[partial]
     pub rpc: Option<RpcConfig>,
 
@@ -191,6 +195,7 @@ impl Default for NodeConfig {
             mempool: Default::default(),
             internal_queue: Default::default(),
             validator: Default::default(),
+            slasher: Default::default(),
             rpc: Some(Default::default()),
             control: Default::default(),
             metrics: Some(Default::default()),

cli/src/node/mod.rs

@@ -31,6 +31,7 @@ use tycho_core::node::{NodeBase, NodeKeys};
 use tycho_core::storage::NodeSyncState;
 use tycho_network::InboundRequestMeta;
 use tycho_rpc::{NodeBaseInitRpc, RpcConfig};
+use tycho_slasher::SlasherConfig;
 use tycho_types::models::*;
 use tycho_util::futures::JoinTask;
 use tycho_wu_tuner::service::WuTunerServiceBuilder;
@@ -54,6 +55,7 @@ pub struct Node {
     collator_config: CollatorConfig,
     validator_config: ValidatorStdImplConfig,
     internal_queue_config: QueueConfig,
+    slasher_config: SlasherConfig,
     mempool_config_override: Option<MempoolGlobalConfig>,
 
     /// Path to the work units tuner config.
@@ -114,6 +116,7 @@ impl Node {
             collator_config: node_config.collator,
             validator_config: node_config.validator,
             internal_queue_config: node_config.internal_queue,
+            slasher_config: node_config.slasher,
             mempool_config_override: global_config.mempool,
             wu_tuner_config_path,
         })
@@ -202,7 +205,12 @@ impl Node {
         message_queue_adapter.clear_uncommitted_state(&top_shards)?;
 
         // NOTE: Stub
-        let slasher = tycho_slasher::Slasher::new(base.keypair.clone());
+        let slasher = tycho_slasher::Slasher::new(
+            base.keypair.clone(),
+            tycho_slasher::StubSlasherContract,
+            base.blockchain_rpc_client.clone(),
+            self.slasher_config,
+        );
 
         let validator = ValidatorStdImpl::new(
             ValidatorNetworkContext {

collator/src/manager/mod.rs

@@ -15,7 +15,7 @@ use tycho_core::storage::ShardStateStorageError;
 use tycho_crypto::ed25519::KeyPair;
 use tycho_types::models::{
     BlockId, BlockIdShort, CollationConfig, GlobalCapabilities, IndexedValidatorDescription,
-    ProcessedUptoInfo, ShardIdent, ValidatorDescription,
+    ProcessedUptoInfo, ShardIdent,
 };
 use tycho_util::futures::AwaitBlocking;
 use tycho_util::metrics::HistogramGuard;

collator/src/manager/utils.rs

@@ -1,5 +1,4 @@
 use tycho_crypto::ed25519::{KeyPair, PublicKey};
-use tycho_types::models::ValidatorDescription;
 use tycho_util::FastHashMap;
 
 pub fn find_us_in_collators_set<T>(

collator/tests/collation_tests.rs

@@ -18,7 +18,7 @@ use tycho_core::block_strider::{
     PersistentBlockStriderState, PrintSubscriber, StateSubscriber, StateSubscriberContext,
 };
 use tycho_crypto::ed25519;
-use tycho_slasher_traits::NoopValidatorEventsListener;
+use tycho_slasher_traits::NoopValidatorEventsRecorder;
 use tycho_types::models::BlockId;
 
 mod common;
@@ -120,7 +120,7 @@ async fn test_collation_process_on_stubs() {
             validator_network,
             node_1_keypair.clone(),
             Default::default(),
-            Arc::new(NoopValidatorEventsListener),
+            Arc::new(NoopValidatorEventsRecorder),
         ),
         CollatorStdImplFactory {
             wu_tuner_event_sender: None,

collator/tests/validator_tests.rs

@@ -9,9 +9,9 @@ use tycho_collator::validator::{
 };
 use tycho_crypto::ed25519;
 use tycho_network::{DhtClient, PeerInfo};
-use tycho_slasher_traits::NoopValidatorEventsListener;
+use tycho_slasher_traits::NoopValidatorEventsRecorder;
 use tycho_types::cell::HashBytes;
-use tycho_types::models::{BlockId, ShardIdent, ValidatorDescription};
+use tycho_types::models::{BlockId, IndexedValidatorDescription, ShardIdent, ValidatorDescription};
 use tycho_util::futures::JoinTask;
 
 mod common;
@@ -24,7 +24,7 @@ struct ValidatorNode {
 }
 
 impl ValidatorNode {
-    fn generate(zerostate_id: &BlockId, rng: &mut impl rand::Rng) -> Self {
+    fn generate(zerostate_id: &BlockId, rng: &mut impl rand::Rng, idx: u16) -> Self {
         let secret_key = rng.random::<ed25519::SecretKey>();
         let keypair = Arc::new(ed25519::KeyPair::from(&secret_key));
 
@@ -33,6 +33,7 @@ impl ValidatorNode {
             peer_id: *validator_network.network.peer_id(),
             public_key: keypair.public_key,
             weight: 1,
+            validator_idx: idx,
         };
 
         let network = &validator_network.network;
@@ -46,7 +47,7 @@ impl ValidatorNode {
             validator_network,
             keypair.clone(),
             ValidatorStdImplConfig::default(),
-            Arc::new(NoopValidatorEventsListener),
+            Arc::new(NoopValidatorEventsRecorder),
         );
 
         Self {
@@ -64,7 +65,7 @@ fn generate_network(
     rng: &mut impl rand::Rng,
 ) -> Vec<ValidatorNode> {
     let nodes = (0..node_count)
-        .map(|_| ValidatorNode::generate(zerostate_id, rng))
+        .map(|i| ValidatorNode::generate(zerostate_id, rng, i as u16))
         .collect::<Vec<_>>();
 
     for i in 0..nodes.len() {
@@ -83,16 +84,19 @@ fn generate_network(
     nodes
 }
 
-fn make_description(seqno: u32, nodes: &[ValidatorNode]) -> Vec<ValidatorDescription> {
+fn make_description(seqno: u32, nodes: &[ValidatorNode]) -> Vec<IndexedValidatorDescription> {
     let mut validators = Vec::with_capacity(nodes.len());
     let mut prev_total_weight = 0;
-    for node in nodes {
-        validators.push(ValidatorDescription {
-            public_key: HashBytes(*node.descr.public_key.as_bytes()),
-            weight: 1,
-            adnl_addr: Some(HashBytes(*node.descr.peer_id.as_bytes())),
-            mc_seqno_since: seqno,
-            prev_total_weight,
+    for (i, node) in nodes.iter().enumerate() {
+        validators.push(IndexedValidatorDescription {
+            desc: ValidatorDescription {
+                public_key: HashBytes(*node.descr.public_key.as_bytes()),
+                weight: 1,
+                adnl_addr: Some(HashBytes(*node.descr.peer_id.as_bytes())),
+                mc_seqno_since: seqno,
+                prev_total_weight,
+            },
+            validator_idx: i as u16,
         });
         prev_total_weight += node.descr.weight;
     }

contracts/src/slasher-stub.tolk

@@ -0,0 +1,50 @@
+import "@stdlib/gas-payments"
+import "lib/config-params"
+
+const ERROR_INVALID_SIGNATURE = 40
+const ERROR_VALIDATOR_NOT_FOUND = 50
+const ERROR_REPLAY_PROTECTION = 52
+const ERROR_MESSAGE_EXPIRED = 57
+
+const REPLAY_OFFSET_MS = 5000
+const FUTURE_OFFSET_SEC = 60
+
+struct Storage {
+    updatedAtMs: uint64
+}
+
+fun Storage.load(): Storage {
+    return Storage.fromCell(contract.getData());
+}
+
+fun Storage.save(self) {
+    contract.setData(self.toCell());
+}
+
+fun onInternalMessage(_in: InMessage) {}
+
+fun onExternalMessage(inMsg: slice) {
+    val signature = inMsg.loadBits(512);
+    val signedBody = inMsg;
+    val createdAtMs = inMsg.loadUint(64);
+    val expireAtSec = inMsg.loadUint(32);
+    val validatorIdx = inMsg.loadUint(16);
+    inMsg.assertEnd();
+    assert(blockchain.now() <= expireAtSec, ERROR_MESSAGE_EXPIRED);
+
+    var data = Storage.load();
+    assert(createdAtMs > (data.updatedAtMs - REPLAY_OFFSET_MS) &&
+    createdAtMs <= (blockchain.now() + FUTURE_OFFSET_SEC) * 1000, ERROR_REPLAY_PROTECTION);
+
+    var validatorCs = CurrentVset.getValidatorDescription(validatorIdx);
+    assert(validatorCs != null, ERROR_VALIDATOR_NOT_FOUND);
+    val validator = ValidatorDescr.readFromSlice(mutate validatorCs);
+
+    val toSign = beginCell().storeSlice(signedBody).endCell();
+    assert(isSignatureValid(toSign.hash(), signature, validator.pubkey), ERROR_INVALID_SIGNATURE);
+
+    data.updatedAtMs = max(createdAtMs, data.updatedAtMs);
+    data.save();
+
+    acceptExternalMessage();
+}

contracts/wrappers/SlasherStub.compile.ts

@@ -0,0 +1,9 @@
+import { CompilerConfig } from "@ton/blueprint";
+
+export const compile: CompilerConfig = {
+  lang: "tolk",
+  entrypoint: "src/slasher-stub.tolk",
+  withStackComments: true,
+  withSrcLineComments: true,
+  experimentalOptions: "",
+};

scripts/build-contracts.sh

@@ -19,3 +19,4 @@ yarn build --all
 copy_code Elector
 copy_code ElectorPoA
 copy_code Config
+copy_code SlasherStub

slasher-traits/src/validator.rs

@@ -156,7 +156,7 @@ impl BlockValidationScope {
     pub fn commit(&self) -> bool {
         if self.seal() {
             // TODO: Use some unsafe magic to make this closer to a NOOP.
-            let mut signatures = Arc::new_uninit_slice(self.signature_slots.len() as usize);
+            let mut signatures = Arc::new_uninit_slice(self.signature_slots.len());
             for (res, slot) in std::iter::zip(
                 Arc::get_mut(&mut signatures).unwrap(),
                 &self.signature_slots,