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 {

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/Cargo.toml

@@ -23,7 +23,7 @@ tokio = { workspace = true, features = ["sync"] }
 tokio-util = { workspace = true }
 tracing = { workspace = true }
 tycho-crypto = { workspace = true }
-tycho-types = { workspace = true }
+tycho-types = { workspace = true, features = ["abi", "models"] }
 
 # local deps
 tycho-block-util = { workspace = true }

slasher/src/bc/mod.rs

@@ -11,12 +11,14 @@ use tycho_types::models::{
 };
 use tycho_util::FastDashMap;
 
+pub use self::stub_contract::StubSlasherContract;
 use crate::util::AtomicBitSet;
 
 mod stub_contract;
 
 #[derive(Clone, Copy)]
 pub struct EncodeBlocksBatchMessage<'a> {
+    pub address: &'a StdAddr,
     pub session_id: ValidationSessionId,
     pub batch: &'a BlocksBatch,
     pub validator_idx: u16,

slasher/src/bc/stub_contract.rs

@@ -1,6 +1,7 @@
 use std::num::NonZeroU32;
 
 use anyhow::{Context, Result};
+use tycho_types::abi::extend_signature_with_id;
 use tycho_types::cell::Lazy;
 use tycho_types::dict;
 use tycho_types::models::{
@@ -10,11 +11,17 @@ use tycho_types::prelude::*;
 
 use super::{BlocksBatch, SignedMessage, SlasherContract};
 
-pub struct StubContract;
+const PARAM_IDX: u32 = 666;
 
-impl SlasherContract for StubContract {
-    fn find_account_address(&self, _config: &BlockchainConfigParams) -> Result<Option<StdAddr>> {
-        Ok(None)
+pub struct StubSlasherContract;
+
+impl SlasherContract for StubSlasherContract {
+    fn find_account_address(&self, config: &BlockchainConfigParams) -> Result<Option<StdAddr>> {
+        let Some(raw) = config.get_raw_cell_ref(PARAM_IDX)? else {
+            return Ok(None);
+        };
+        let address = raw.parse::<HashBytes>()?;
+        Ok(Some(StdAddr::new(-1, address)))
     }
 
     fn default_batch_size(&self) -> NonZeroU32 {
@@ -33,16 +40,35 @@ impl SlasherContract for StubContract {
             .context("failed to serialize blocks batch")?;
 
         let now = tycho_util::time::now_millis();
-
         let expire_at = (now / 1000).saturating_add(params.ttl.as_secs()) as u32;
+        let body_to_sign = {
+            let mut b = CellBuilder::new();
+            b.store_u64(now)?;
+            b.store_u32(expire_at)?;
+            b.store_u16(params.validator_idx)?;
+            b.store_reference(cell)?;
+            b.build()?
+        };
+
+        // TODO: Add support for signature id.
+        let signature = params.keypair.sign_raw(&extend_signature_with_id(
+            body_to_sign.repr_hash().as_array(),
+            None,
+        ));
+        let body = {
+            let mut b = CellBuilder::new();
+            b.store_raw(&signature, 512)?;
+            b.store_slice(body_to_sign.as_slice()?)?;
+            b.build()?
+        };
+
         let message = Lazy::new(&OwnedMessage {
             info: MsgInfo::ExtIn(ExtInMsgInfo {
-                // Stub address.
-                dst: StdAddr::new(-1, HashBytes::ZERO).into(),
+                dst: params.address.clone().into(),
                 ..Default::default()
             }),
             init: None,
-            body: cell.into(),
+            body: body.into(),
             layout: None,
         })?;
 

slasher/src/lib.rs

@@ -14,13 +14,13 @@ use tycho_core::blockchain_rpc::BlockchainRpcClient;
 use tycho_crypto::ed25519;
 use tycho_slasher_traits::{ValidationSessionId, ValidatorEventsListener};
 use tycho_types::boc::Boc;
+use tycho_util::config::PartialConfig;
 use tycho_util::futures::JoinTask;
 use tycho_util::serde_helpers;
 
-use self::bc::MessageDeliveryStatus;
 pub use self::bc::{
-    BlocksBatch, ContractSubscription, EncodeBlocksBatchMessage, SignatureHistory, SignedMessage,
-    SlasherContract,
+    BlocksBatch, ContractSubscription, EncodeBlocksBatchMessage, MessageDeliveryStatus,
+    SignatureHistory, SignedMessage, SlasherContract, StubSlasherContract,
 };
 use self::collector::{ValidatorEventsCollector, ValidatorSessionInfo};
 
@@ -34,7 +34,7 @@ pub mod collector {
 mod bc;
 mod util;
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialConfig)]
 pub struct SlasherConfig {
     /// TTL of messages to the slasher contract.
     ///
@@ -220,20 +220,21 @@ impl SlasherSharedState {
         validator_idx: u16,
         batch: BlocksBatch,
     ) {
-        let params = EncodeBlocksBatchMessage {
-            session_id,
-            batch: &batch,
-            validator_idx,
-            keypair: &self.node_keys,
-            ttl: self.config.message_ttl,
-        };
-
         loop {
             let Some(subscription) = self.subscription.load_full() else {
                 tracing::warn!("no slasher contract subscription");
                 break;
             };
 
+            let params = EncodeBlocksBatchMessage {
+                address: subscription.address(),
+                session_id,
+                batch: &batch,
+                validator_idx,
+                keypair: &self.node_keys,
+                ttl: self.config.message_ttl,
+            };
+
             let signed = match self.contract.encode_blocks_batch_message(&params) {
                 Ok(signed) => signed,
                 Err(e) => {