diff --git a/Cargo.lock b/Cargo.lock index ab42a8d77..b8ff98545 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1589,6 +1589,15 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "signal-hook-registry" +version = "1.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" +dependencies = [ + "libc", +] + [[package]] name = "signature" version = "2.2.0" @@ -1861,7 +1870,9 @@ dependencies = [ "libc", "mio", "num_cpus", + "parking_lot", "pin-project-lite", + "signal-hook-registry", "socket2", "tokio-macros", "windows-sys 0.48.0", @@ -2031,6 +2042,7 @@ dependencies = [ "castaway", "everscale-types", "futures-util", + "tokio", "tracing", "tycho-network", "tycho-storage", diff --git a/Cargo.toml b/Cargo.toml index bd2ea64f2..2c71a97f5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,14 @@ [workspace] +members = [ + "consensus", + "core", + "network", + "simulator", + "storage", + "util", + "collator", +] resolver = "2" -members = ["consensus", "core", "network", "simulator", "storage", "util", "collator"] [profile.release] debug = true @@ -73,8 +81,8 @@ rest_pat_in_fully_bound_structs = "warn" same_functions_in_if_condition = "warn" semicolon_if_nothing_returned = "warn" single_match_else = "warn" -string_add_assign = "warn" string_add = "warn" +string_add_assign = "warn" string_lit_as_bytes = "warn" string_to_string = "warn" todo = "warn" diff --git a/core/Cargo.toml b/core/Cargo.toml index f6a6fc6a0..f5f49b53e 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -1,8 +1,8 @@ [package] +description = "Basic functionality of peer." +edition = "2021" name = "tycho-core" version = "0.0.1" -edition = "2021" -description = "Basic functionality of peer." [dependencies] anyhow = "1.0.80" @@ -11,6 +11,7 @@ castaway = "0.2" everscale-types = "0.1.0-rc.6" futures-util = "0.3.30" tracing = "0.1.40" +tokio = { version = "1.36.0", features = ["full"] } # local deps tycho-network = { path = "../network", version = "=0.0.1" } diff --git a/core/src/block_strider/mod.rs b/core/src/block_strider/mod.rs index d82565432..e2f60d022 100644 --- a/core/src/block_strider/mod.rs +++ b/core/src/block_strider/mod.rs @@ -1,9 +1,13 @@ -use std::future::Future; -use std::sync::atomic::{AtomicBool, Ordering}; - use anyhow::Result; use everscale_types::models::{Block, BlockId}; -use futures_util::future::BoxFuture; + +pub mod provider; +pub mod state; +pub mod subscriber; + +use provider::BlockProvider; +use state::BlockStriderState; +use subscriber::BlockSubscriber; pub struct BlockStriderBuilder(BlockStrider); @@ -140,62 +144,6 @@ where } } -pub trait BlockStriderState: Send + Sync + 'static { - fn load_last_traversed_master_block_id(&self) -> BlockId; - fn is_traversed(&self, block_id: &BlockId) -> bool; - fn commit_traversed(&self, block_id: BlockId); -} - -impl BlockStriderState for Box { - fn load_last_traversed_master_block_id(&self) -> BlockId { - ::load_last_traversed_master_block_id(self) - } - - fn is_traversed(&self, block_id: &BlockId) -> bool { - ::is_traversed(self, block_id) - } - - fn commit_traversed(&self, block_id: BlockId) { - ::commit_traversed(self, block_id); - } -} - -/// Block provider *MUST* validate the block before returning it. -pub trait BlockProvider: Send + Sync + 'static { - type GetNextBlockFut<'a>: Future>> + Send + 'a; - type GetBlockFut<'a>: Future>> + Send + 'a; - - fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a>; - fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a>; -} - -impl BlockProvider for Box { - type GetNextBlockFut<'a> = T::GetNextBlockFut<'a>; - type GetBlockFut<'a> = T::GetBlockFut<'a>; - - fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { - ::get_next_block(self, prev_block_id) - } - - fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { - ::get_block(self, block_id) - } -} - -pub trait BlockSubscriber: Send + Sync + 'static { - type HandleBlockFut: Future> + Send + 'static; - - fn handle_block(&self, block: &Block) -> Self::HandleBlockFut; -} - -impl BlockSubscriber for Box { - type HandleBlockFut = T::HandleBlockFut; - - fn handle_block(&self, block: &Block) -> Self::HandleBlockFut { - ::handle_block(self, block) - } -} - fn get_shard_hashes(_block: &Block) -> impl IntoIterator { vec![].into_iter() } @@ -203,38 +151,3 @@ fn get_shard_hashes(_block: &Block) -> impl IntoIterator { fn get_block_id(_block: &Block) -> BlockId { unimplemented!() } - -// === Provider combinators === -struct ChainBlockProvider { - left: T1, - right: T2, - is_right: AtomicBool, -} - -impl BlockProvider for ChainBlockProvider { - type GetNextBlockFut<'a> = BoxFuture<'a, Option>>; - type GetBlockFut<'a> = BoxFuture<'a, Option>>; - - fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { - Box::pin(async move { - if !self.is_right.load(Ordering::Acquire) { - let res = self.left.get_next_block(prev_block_id).await; - if res.is_some() { - return res; - } - self.is_right.store(true, Ordering::Release); - } - self.right.get_next_block(prev_block_id).await - }) - } - - fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { - Box::pin(async { - let res = self.left.get_block(block_id).await; - if res.is_some() { - return res; - } - self.right.get_block(block_id).await - }) - } -} diff --git a/core/src/block_strider/provider.rs b/core/src/block_strider/provider.rs new file mode 100644 index 000000000..edda7d7d5 --- /dev/null +++ b/core/src/block_strider/provider.rs @@ -0,0 +1,162 @@ +use everscale_types::models::{Block, BlockId}; +use futures_util::future::BoxFuture; +use std::future::Future; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; + +/// Block provider *MUST* validate the block before returning it. +pub trait BlockProvider: Send + Sync + 'static { + type GetNextBlockFut<'a>: Future>> + Send + 'a; + type GetBlockFut<'a>: Future>> + Send + 'a; + + fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a>; + fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a>; +} + +impl BlockProvider for Box { + type GetNextBlockFut<'a> = T::GetNextBlockFut<'a>; + type GetBlockFut<'a> = T::GetBlockFut<'a>; + + fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { + ::get_next_block(self, prev_block_id) + } + + fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { + ::get_block(self, block_id) + } +} + +impl BlockProvider for Arc { + type GetNextBlockFut<'a> = T::GetNextBlockFut<'a>; + type GetBlockFut<'a> = T::GetBlockFut<'a>; + + fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { + ::get_next_block(self, prev_block_id) + } + + fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { + ::get_block(self, block_id) + } +} + +// === Provider combinators === +struct ChainBlockProvider { + left: T1, + right: T2, + is_right: AtomicBool, +} + +impl BlockProvider for ChainBlockProvider { + type GetNextBlockFut<'a> = BoxFuture<'a, Option>>; + type GetBlockFut<'a> = BoxFuture<'a, Option>>; + + fn get_next_block<'a>(&'a self, prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { + Box::pin(async move { + if !self.is_right.load(Ordering::Acquire) { + let res = self.left.get_next_block(prev_block_id).await; + if res.is_some() { + return res; + } + self.is_right.store(true, Ordering::Release); + } + self.right.get_next_block(prev_block_id).await + }) + } + + fn get_block<'a>(&'a self, block_id: &'a BlockId) -> Self::GetBlockFut<'a> { + Box::pin(async { + let res = self.left.get_block(block_id).await; + if res.is_some() { + return res; + } + self.right.get_block(block_id).await + }) + } +} + +#[cfg(test)] +mod test { + use super::*; + use std::sync::atomic::{AtomicBool, Ordering}; + use std::sync::Arc; + + struct MockBlockProvider { + // let's give it some state, pretending it's useful + has_block: AtomicBool, + } + + impl BlockProvider for MockBlockProvider { + type GetNextBlockFut<'a> = BoxFuture<'a, Option>>; + type GetBlockFut<'a> = BoxFuture<'a, Option>>; + + fn get_next_block<'a>(&'a self, _prev_block_id: &'a BlockId) -> Self::GetNextBlockFut<'a> { + Box::pin(async { + if self.has_block.load(Ordering::Acquire) { + Some(Ok(get_empty_block())) + } else { + None + } + }) + } + + fn get_block<'a>(&'a self, _block_id: &'a BlockId) -> Self::GetBlockFut<'a> { + Box::pin(async { + if self.has_block.load(Ordering::Acquire) { + Some(Ok(get_empty_block())) + } else { + None + } + }) + } + } + + #[tokio::test] + async fn chain_block_provider_switches_providers_correctly() { + let left_provider = Arc::new(MockBlockProvider { + has_block: AtomicBool::new(true), + }); + let right_provider = Arc::new(MockBlockProvider { + has_block: AtomicBool::new(false), + }); + + let chain_provider = ChainBlockProvider { + left: Arc::clone(&left_provider), + right: Arc::clone(&right_provider), + is_right: AtomicBool::new(false), + }; + + chain_provider + .get_next_block(&get_default_block_id()) + .await + .unwrap() + .unwrap(); + + // Now let's pretend the left provider ran out of blocks. + left_provider.has_block.store(false, Ordering::Release); + right_provider.has_block.store(true, Ordering::Release); + + chain_provider + .get_next_block(&get_default_block_id()) + .await + .unwrap() + .unwrap(); + + // End of blocks stream for both providers + left_provider.has_block.store(false, Ordering::Release); + right_provider.has_block.store(false, Ordering::Release); + + assert!(chain_provider + .get_next_block(&get_default_block_id()) + .await + .is_none()); + } + + fn get_empty_block() -> Block { + let block = "te6ccgICAUIAAQAAJskAAAQQEe9VqgAAACoBQAE6AC4AAQSJSjP2/Ssa2wF5uEEwrk0mpfzxnwEqomhdLCsCIi8S117QxhfmT6V1y6kwADcR/FAF+6gGU5INPMDPQUH54IdjltWWUObAACQAIwAGAAIDF8ylaHc1lABDuaygBABjAAUAAwEBUAAEAgFhACwAJgA/sAAAAABAAAAAAAAAACHc1lABDuaygAh3NZQAQ7msoAQBAYIABwIDQEAADQAIApe/lVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUCqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrQAAAKuLfGgWDBAAkADAOvdVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVQAAKuLfGgWD+OU5XWVsll83JaVXDoaipjd5RB+ufA9eGnVy89mUasYAACri3wrDQ2Xd1PUAAUCAAiAAwACgIFMDAkAAsAKACgQR1QF9eEAAAAAAAAAAAALgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgnK1uKlymbKzxB1QqVryaRnWhafoupL3wQvLnuHlFsKy5TQjJ9XzMywxxVyvqAUcc4Cybz8hJ6/AWh/u6h5c4YLrAgEBABYADgOXv2ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmBTMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMznwAAFXFvjQLACAARABAADwCCci3njpKuCvD5zhZwVZHIGCqWsRIVUxfHi8NrZOjwpF/tJalyz0Q5l77RDcNPr2YBLOoxAgE4Hh103gWDCBdYlYMBA0BAACYBA1BAABIDr3MzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMAACri3xoFgYTRLryZhGkHVLwJlJSfEESqKe943qn8IX5WypYTLZjJAAAq4t8Kw0Jl3dT1AAFAgAIgAVABMCBSAwJAAUACgAoEMPEBfXhAAAAAAAAAAAAJYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJyLeeOkq4K8PnOFnBVkcgYKpaxEhVTF8eLw2tk6PCkX+16iTumPmcpzNmKcrBzgLotmFPLP9dpk6rVv9k/9HTCpgOXv0nsmNX3/nuiGxdM4O8hWSzhqoHm9SiRYGb3VNS1JVlYBQT2TGr7/z3RDYumcHeQrJZw1UDzepRIsDN7qmpakqysnwAAFXFvjQLACAAcABgAFwCCcsr/DEO4Zth9d1cNRR/zEr+XRahhPZRrpaK+Q94Jh9m0PnhOxpGZNKx+DjL8Pck9tVk7eINNCAnB73tMtVUQod4BA1BAABkDr3BPZMavv/PdENi6Zwd5CslnDVQPN6lEiwM3uqalqSrKwAACri3xoFg28MQaOYe5EB8gggekIGeksPZVSlOV28pEgkW1lYNHKDAAAq4t8aBYFl3dT1AAFAgAIgAbABoCBTAwNAAgAB8AgnIXeaxhjM9e0jc9bFkBhsHxsl0Ot2mqExuljuU4YNUz7D54TsaRmTSsfg4y/D3JPbVZO3iDTQgJwe97TLVVEKHeAQNQQAAdA69wT2TGr7/z3RDYumcHeQrJZw1UDzepRIsDN7qmpakqysAAAq4t8aBYG5UrMQIlqVwZM3xvhPH/f2W1FaKRAyUKRw7Ej+cbKNzAAAKuLfCsNDZd3U9QABQIACIAIQAeAgUgMDQAIAAfAGlgAAAAlgAAAAQABgAAAAAABRmuhPF7j4siAmqXX/VfGrGf3kp2h0TSF436Y7tTPhB6QJAmvACgQmZQF9eEAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgnLK/wxDuGbYfXdXDUUf8xK/l0WoYT2Ua6WivkPeCYfZtBd5rGGMz17SNz1sWQGGwfGyXQ63aaoTG6WO5Thg1TPsAAEgAAECAQOAIAAlAkegBrLsruJlSBbR/KwrDdQ86u5e9NlCUSbhNwdaaJysZEsgBhAALAAmA69zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzAAAq4t8aBYL/Gu2gvFcf8ibjSTGt30g73/BAgJ6pnJ4AYngH6BteMQAAKuLfGgWBZd3U9QABQIACsAKgAnAg8ECSg7rsAYEQApACgAW8AAAAAAAAAAAAAAAAEtRS2kSeULjPfdJ4YfFGEir+G1RruLcPyCFvDGFBOfjgQAnkJhTBB6wAAAAAAAAAAAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgnJ6iTumPmcpzNmKcrBzgLotmFPLP9dpk6rVv9k/9HTCpiWpcs9EOZe+0Q3DT69mASzqMQIBOB4ddN4FgwgXWJWDAQGgAC0BBkYGAAAtAKtp/gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABP8zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM0oO67AAAAABVxb40CwDLu6nqQAqKBMggVqAGVLSnZH0vSi+EB8ij+Qi9iC0mhKwad2CB/HkjrIRBLWnICqfv/Y33zYEvV1zFwdh9LT7EHFH5QG9BbSkAswCzAJAALyRbkCOv4gAAACoA/////wAAAAAAAAAAAiZkTwAAAABl3dT1AAAq4t8aBYUCJmRMYACOAGcAZgAwJFXMJqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqwjbMCx67a5VmAGMA/AAxATgivwABfOWt5wAHW7dgAAVcW+FYaKgAAVbyyFgSKBEw5vKL1XMczH2e9DjKneuYA3U5k89852SIu5/5GbOBGvMi4MhhtFhdh8KUJMl+PI0AGLs7WH9v0AvTuvgkqXPWEF/YvgBUADIiASAAMwCUIgEgAEkANCIBIAA1AJciASAAQQA2IgEgADcAmiIBIAA4AJwiASAAOQCeIgEgAKkAOiIBIACoADsiASAAPACiIgEgAD0ApCIBWAA+AKYCAWoAQAA/AK+8FCUfh/tKesSYHkT7XWwEnkbHCz9FMqz+m6/q0W2HEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGXd1PUAAAAAAAAAMgAAAAG2vtDrAAAAInY8m2GAK+8KUYneUcjzbYzME9sWTLFA/eObsOrXGzDWpSqNCTy0Zc8FRAAAAAAAAADqAAAABs8WG4UAAACS2yjCRGXO4ZQAAAAAAAAAqQAAAAsk33NOAAAAdxMRWXWIgEgALgAQiIBIAC3AEMiASAAtgBEIgEgALUARSIBIAC0AEYiASAARwCwIgEgALMASACxvUrrl1JgAG4j+KAL91AMpyQaeYGegoPzwQ7HLassocyMu7qeoAAAAAAAABjgAAABKSz7H2AAABFESi5grLu6GoAAAAAAAAAbgAAAAVau7DCgAAATCPxqy3AiASAASgC6IgEgAEsAvCIBIABMAL4iASAATQDAIgEgAE4AwiIBIABPAMQiASAAUADGIgEgAFEAyCIBIABSAMoiASAAUwDMAHPeiMu7qeoAAAAABEzIngAABYeQr3+0AACtdanKh3LLu6nqAAAAADJ53PwAAAW+vkhAEAAAtk9y5s/fIhPDQAAKuLfCsNFgAOIAVSITcIAAFXFvhWGiwADhAFYiEWIAAFXFvhWGiwDgAFciESAABVxb4VhosADfAFgiEWIAAFXFvhWGiwDeAFkiEQAABVxb4VhosADdAFoiEWAAAFXFvhWGiwDcAFsiEsYAACri3wrDRQDbAFwiEWAAAFXFvhWGiwDaAF0iEQAABVxb4VhosADZAF4CEQAABVxb4VhosABgAF8AqUAAAVcW+FYaKAAAq4t8Kw0UCJmROjhZFcIoE59qpgQZLkwYmxh2/kLRoBIjchvyqFblZu/ChSRhP2ZDmNemtnyucHDk3L8gGUPvXLNcUNJXwKVhv5ICEQAABVxb33AgsABiAGEAqQAABVxb33AgoAACri3vuBBQImZE3SqTiSAu5BRlYnm5CyCNDB+89T5D22yHoUXKibpDkGxIr3qGFh3ESwo1FoH5adbkzwZ9Hm24HvwByVR2y+x8y2gAqQAABVxb3YfYoAACri3uw+xQImZExnT+xZwTC1+5bd2oLyOlj2DvmBQhabAjSc+mcTY9XIT3HvhygeRTfjMZKzrOpZyF1ReddNR979/Ej3wbTj21E/gBA9BAAGQB21AU9hmYETMieAABVxb4VhoAAAFXFvhWGg6LzN/hmFciMlMXrwmaluwkwaMGVBE0z2uKL7JStK6lqp/SiWxpaHsAXeZ6TEeDoTcL6Z5vOXQ7LUp23SI+x0QIgAA657wAAAAAAAAAABEzImMu7qeKAGUAE0O5rKACHc1lACAiMwAAAAAAAAAA//////////+DalIL9XRkrtgoATgA5SITgg2pSC/V0ZK7cABoATgjEwEG1KQX6ujJXbgAaQDoATgjEwEBe4OAgzgdRVgAdgBqATgiEQD2+7EUBnF8CABrAOsiEQDgYpbCPOlfCAEAAGwiDwDBhKrnx9IoAG0A7iINAKlp0PfNSAD/AG4iDQClybYWkKgAbwDxIg0AoUsFsbbIAP4AcCINAKCRhUcwCABxAPQiDVAoHTwtTfoAcgD2Ig91AoFwyX6ZoABzAPghm7xqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqgUCy0HtMAa0Xizz45zp6cPvperioI+MZoYa4V6NI1BzqziBS6FPAAAVcW+NAsHAB0InXP9VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVUB4LA+8kAAAAAAAAAq4t8aBYRQLLQe0wV0AD9AHUoSAEBB5x4BQd89OfNQnWhDgYEbzsMYYHinM8igzT8qRxM5y8ADyMTAQFkh89vMavJWACDAHcBOCITAQFke8ojnRDRyAEZAHgiEwEBZHujejYVmQgAeQEEIhMBAWR7nBpHLozoAHoBBiITAQFke49Gls3ZiAEYAHsiEwEBZHuOWPHP40gBFwB8IhMBAWR7jlcPr1mIAH0BCiIVcwQFke44TMumBaAAfgEMIlG8GZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZgQFke44TMumBaAB/AQ4hY/AgLI9xwmP61i0jZUCN3W9j7uTfaCTJow6vXFPp770J2tdEekAR5rpp0gAAVcW+NAsFAIAie8/zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzQHwMFPbkAAAAAAAACri3xoFg4CyPccJj+tYtbQARYAgSNN5AVWy7oL1ARG88MSbjCPjrK9gP6cSyja6wjB7A8mnxa900NUhoEPARUBFACCIXmgZd0F6mXeheoAAIAAAiN54Yk3GEfHWV7Af04llG11hGD2B5NPi17poapDQIfAKsCtKW2ZLFsW9jBQKfwgARMjDwDMBUuUmveYAIQBGwE4Iw8Ax81sulAImACFAR0BOCMPAMAm6uyNkzgAjQCGATgiDQCjokFr1ggAhwEgIg0AojPTixNoAIgBIiINAKErInG6iAEtAIkiDQCgwC7O9CgBLACKIg1QKBLTH7wqASsAiyGavRkxq+/890Q2LpnB3kKyWcNVA83qUSLAze6pqWpKsrAIFqalJtyEY+XcMpxRp5lWy6fQAMYkJKE7iRIoqOg4PMoNcm65AAAq4t8aBYMAjCNvz/BPZMavv/PdENi6Zwd5CslnDVQPN6lEiwM3uqalqSrKwhiB9IAAAAAAAACri3xoFhEC1NSk1/ABKgEpASgoSAEBUIEL15n/BmXEMwww5UhMDG0rLSfmEKd3FEU21oiaRPUADwERAAAAAAAAAABQAI8Aa7BAAAAAAAAAAAETMieAABVxb4Vhon//////////////////////////////////////////wCRbkCOv4gAAACoA/////wAAAAAAAAAAAiZkTgAAAABl3dTyAAAq4t8Kw0UCJmRLYAE5AOYA5ACRJFXMJqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqwjbMCxmz9b1mAOMA/ACSATgivwABfOWt5wAHW7dgAAVcW99wIKgAAVbyyFgSKBEw5vKL1XMczH2e9DjKneuYA3U5k89852SIu5/5GbOBGvMi4MhhtFhdh8KUJMl+PI0AGLs7WH9v0AvTuvgkqXPWEF/YvgDOAJMiASAAlQCUKEgBAXDfCrJ1dQ95iQCh0Fzhy0K0wsZl28+e0FzB6wzQkdFmAA8iASAAuQCWIgEgAJgAlyhIAQHrP5FgbE7wig1AJzy9BiaMtbNKmW5B8ju6J/BycPXeawANIgEgAKoAmSIBIACbAJooSAEBj09fEN+OTGeSUm+/Qm8Ny9V13YduXlcF6Vq74hT1wZIACiIBIACdAJwoSAEB0ssE0qhY0ZY+dWdW1hFCsoCb3ZD3XXiky1k2DqbdQq0ACCIBIACfAJ4oSAEBpt2FlSVMvOR5Qxo3rgaRqhw4lHt1DigEvkWm0mY6sKkAByIBIACpAKAiASAAqAChIgEgAKMAoihIAQESRiadDqKqUTHEMUjCTBmzNBOzxsVGLJEhE8/oq0ZEtQADIgEgAKUApChIAQGNMOBIvaUJ9kk380PlSM+L2QjKieqT1ihZ9+mBjz/9+QABIgFYAKcApihIAQGZ02Xi1wIChIThkN4ElBiLwkpbwQalNs5h4L9GbXyvLgABKEgBAWFPmC3o0VEI760jTkcrGHTTHSqNKIJCYnnFR+tujQzxAAEoSAEBJILLjI8lsEzanMfOncCqkFpQZCdsdAw5i7dm8kH6SQAABChIAQH9SjvgDlKWCmVlu8bbdxNyODONwj5jY6yzDedRkGlu/QAFIgEgALgAqyIBIAC3AKwiASAAtgCtIgEgALUAriIBIAC0AK8iASAAsQCwKEgBAW7dFysTan1pycVW9JDrm3OwWmCiPUzMtWEXqwCj1YRjAAMiASAAswCyALG9SuuXUmAAbiP4oAv3UAynJBp5gZ6Cg/PBDsctqyyhzIy7upDgAAAAAAAAGMAAAAEXztfkIAAAESupW5ZMu7oagAAAAAAAABuAAAABVq7sMKAAABMI/GrLcChIAQGtni6Gfiuf5dHVVuegZd5NX0iCztAolxQxgoK06XhcDwABKEgBAdXk6UR6VJptoTGUUP6wOEFQUoiAFSmNZ4KSEy6nYFRbAAcoSAEBJmmxWhWy8uMlEwMqq8hpkAMSNJGzpzD90p5Iy6x13D8ABShIAQEXupPFZHzPPTh2aPevrON2Y/e22PlM4/uLzN8FVGYvkgAHKEgBAb7HcP0c7IU9E9eNCN3CnNRI55gHHA1xKd29qjRe6vgpAAgoSAEBfdPuK+QJBEx0LGz1Z/s9O0BdQm2hGhqbQvhWcOb+zCMACiIBIAC7ALooSAEBSdiRCA+u+Vm8nTY44an4tL9EyQ+FVE+PsleyLnwPma0ADSIBIAC9ALwoSAEBqVY2xOlrlJDhfrzr33ftZscWNg/VuiTiXzA5EA55SUQACyIBIAC/AL4oSAEBdZSJGd2soYmexqFXGG5uwGS/KaUQzmOcltk1Szoxp0kACiIBIADBAMAoSAEB3Fhyv/pX1He+9NQgPJWeVMvt5lBJjuLV2Hr540HiWX4ACSIBIADDAMIoSAEBKUdWHCygcXpInFC0eG1ytbb274FDPyVeF5UvhyggnTwAByIBIADFAMQoSAEBkaJC0D/18Jb44LOyuZz1U8SRCDT8oQIQo/7v9deaZ58ABSIBIADHAMYoSAEBe2lzJDRW8dyzUIHTYRa50ZkhjFLKXob+QggOC9rjzIgABSIBIADJAMgoSAEBndP2h6dgiZ74Iiw9Jpyszpu3aMsNZC+BQ44Q8qLyhNQAAyIBIADLAMoAsb15g0WyCPzci2+fZwFvL/mdFep2Z7Zskdh/zgRArhgMjLmAqOAAAAAAAAAcgAAAAUNim1LAAAASFmgOgqy5f6wAAAAAAAAAEqAAAAKC1oWLwAAADgSxL72wIgEgAM0AzChIAQEufyI2vyUuTNRdiyGaV6+oNgE4TkiutuiC3mnkT6DChAACAHPeiMu7qeQAAAAABEzInAAABYejKTIeAACtdbIokV7Lu6nkAAAAADJ53PoAAAW+5XbtcgAAtk+V0lzzIhPDQAAKuLe+4EFgAOIAzyITcIAAFXFvfcCCwADhANAiEWIAAFXFvfcCCwDgANEiESAABVxb33AgsADfANIiEWIAAFXFvfcCCwDeANMiEQAABVxb33AgsADdANQiEWAAAFXFvfcCCwDcANUiEsYAACri3vuBBQDbANYiEWAAAFXFvfcCCwDaANciEQAABVxb33AgsADZANgoSAEBygQbusbhw10WMgjLYUwXr3lojDayanw2ycVweRs96zcAAShIAQEUcXmN9zxuEANwgxr2QX/TYHSw/CH7c3x2aFVPVtvVpwACKEgBAWHEYGKOD9k3I0+0M4OIFauUs9bgRZUORbociOraaYjCAAMoSAEB/5r4XB39HoYo9XQf2OSyS7Hc7sq5uRbDBDAjdhGOlysABihIAQHdfqKvtd4a+Y+Rz6U0qRFxHrFqvC3VwkEVyhCTfJmDgwAKKEgBASLvz2++iAW86iQ+UEtlft5X2F0+TBkNHbEbRCPFYqqYAA0oSAEBPdxCUkfP/jS1rrwsGXBTjgd4f2wJEBShyoJ3Ordj9CYADihIAQERSjVac2xUWKtJBiGA6rBXmi9drZF8j/QZ45TkHwFPqQARKEgBATuEGW75wfceah7lc5BF2SLHusIl99oiSuHiJbzXj4O4ABIoSAEBK/bbRJjXq4XreEcN+6yy//Xzum9heMZuXzR3QHLKO7sAFShIAQH71a++uifWZbBYlOCyHiXe0BdPeU6qFK4nH7Woo6J2cwAZKEgBAcgadwXezZegAxz0tkVhTp/bcpg/ugp8tKa3AhckXALIAAIiMwAAAAAAAAAA//////////+DalIL62V4/tgoATgA5ShIAQGANr1aplvRYMzE8gSkRzGv22K6sashyUlq8vwbTSJszQADIhOCDalIL62V4/twAOcBOCMTAQbUpBfWyvH9uADpAOgBOChIAQFUbWbQarmoUSjJY0THrBGGNYP/T3K208gYVmK3hF9gZgAZIxMBAXuDgG8aReVYAQEA6gE4IhEA9vuxFAZxfAgA7ADrKEgBAX184jabqEG61a+OPcg65jOWgEoOdxASWckvqYQytfhbABciEQDgYpbCPOlfCAEAAO0iDwDBhKrnx9IoAO8A7ihIAQH6EHA4kfFx5nL7pdHNM3oR+D+zqH2+BYFoAeMVYQUz/wAUIg0AqWnQ981IAP8A8CINAKXJthaQqADyAPEoSAEBaT64fgPsBON1d+mrM2AcaYP7qAajvWTGhfOzdM6Hg/EAECINAKFLBbG2yAD+APMiDQCgkYVHMAgA9QD0KEgBAZcNCn24JKkaOzKADlvTQQmjvgvCAYaOgBr/QrGqkPugAA4iDVAoHTwtTfoA9wD2KEgBAfZJkERvtnQtF+jcom7IfEv9ibCV7Lo6MebeydG0cgY8AAsiD3UCgXDJfpmgAPkA+ChIAQEvd+gseFkzgde2UrZ4Pr/VwV44YKo89lXTsCVFd/F0bwALIZu8aqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqoFAstB7TB8cpyusrZLL5uS0quHQ1FTG7yiD9c+B68NOrl57Mo1YwAAFXFvhWGhwA+iJ1z/VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVAeCwPvJAAAAAAAAAKuLfCsNEUCy0HtMFdAA/QD7IUkAAAAvylP5P5DkA14HhNZBZbbdkIFeMPkTtLKfb1QU8P8ayP1AAPwoSAEBGMI36yb9t0o/gKW3cJUF1CzwACz9+ITFGAW7/BkzVSsADihIAQG6wkvkAbNIn5ABjQgTfEBj8kv8be+Gphg2Bg1tvDLnAwAMKEgBAVHberPVAQ6fEho+YPUqWqy2xxdt7NmuFuAN96UYcDTWAA4oSAEBXPwaHHLzZ5Zb1fhkjmGWAgupDlbiVHIczY1mUUceNygAEShIAQHKrSDADVi1eK8XYUNBUppIN6AO1uez32Nz5vR7uPNIcwAVIxMBAWSHz1sT1GlYARoBAgE4IhMBAWR7yg9/OXHIARkBAyITAQFke6NmGD45CAEFAQQoSAEB3lh4uH5lp5bSrbGiEqzaUKQdgs145kWOJCqmRjPPqocArCITAQFke5wGKVcs6AEHAQYoSAEB0JOJS3Fs2lQKWu27cD1ojJtgHJYFGykh6XZYUuYeqAQAEiITAQFke48yePZ5iAEYAQgiEwEBZHuORNP4g0gBFwEJIhMBAWR7jkLx1/mIAQsBCihIAQFqbL4zR9GEHINEe/7y3wwFKvF9RI8GFAd6jmIVHgpueAANIhVzBAWR7jf8VEiFoAENAQwoSAEBAc6BovOQ7gr6SLWEONWnsHoA9y7xnAfCHTxbAHFKVIMAASJRvBmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmYEBZHuN/xUSIWgBDwEOKEgBAbB/x8oqtru9zgBa+LQVovonLHEil5bsQ8cLbecQcZIsAAEhY/AgLI9xv+A/6i0Jol15MwjSDql4EykpPiCJVFPe8b1T+EL8rZUsJlsxkgAAVcW+FYaFARAie8/zMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzQHwMFPbkAAAAAAAACri3wrDQ4CyPcb/gP+otbQARYBESNN5AVWy7oL1ARG88MSbjCPjrK9gP6cSyja6wjB7A8mnxa900NUhoEPARUBFAESIXmgZd0F6mXeheoAAIAAAiN54Yk3GEfHWV7Af04llG11hGD2B5NPi17poapDQIfAKsCtKW2ZLFsW9d/YzHwgARMoSAEBCz+xJUz0JIwFsspXPtZ3TVIwLmpGbx7jets+Z3CyXikACihIAQGwqptmekrei2HOhS5S9zmieojjoql3+QScfirdYPZwDQAGKEgBAbPZGfQo8fZ+yytdkqhiHTmPUqpYO/g19pofySS8XARsAAsoSAEBy26zEt+Bh6YeOGVj9GQ8FMrSuYNgzg2eeNpJRnGIpm8ADihIAQFSvR1OekLmD61i+OgFmvcQ0cDLNC0fmUwW6ZTGfCV64AABKEgBAZV5g7RWq62rI+ablKQv4hoDwVEqE/ZqlMTO+qts+LsRAA4oSAEBx6iUFxpe5d8TlBviolOgop9IlmkTyoyqS6rbkz/DdaEAFSMPAMwFS5Sa95gBHAEbATgoSAEBuuSS8sx4ObmIJKHsDC+Ng4e+4DbUQb9A1/F7Rvpz4cEAFCMPAMfNbLpQCJgBHgEdATgoSAEBhUPmdah0GqyWIGx/b4n3onWrOma2gaPjA+lIRTtsrHgAFCMPAMAm6uyNkzgBLgEfATgiDQCjokFr1ggBIQEgKEgBAVesg0Jo5XkQqAMlpXUzv6h29gFqogcNKSw9nsz2/K72AA8iDQCiM9OLE2gBIwEiKEgBAcyn/uNmdJxtE4jakkvq1c8bAiEIDoOUcgFYiM8Xsq7QAA4iDQChKyJxuogBLQEkIg0AoMAuzvQoASwBJSINUCgS0x+8KgErASYhmr0ZMavv/PdENi6Zwd5CslnDVQPN6lEiwM3uqalqSrKwCBampSa5UrMQIlqVwZM3xvhPH/f2W1FaKRAyUKRw7Ej+cbKNzAAAKuLfCsNDAScjb8/wT2TGr7/z3RDYumcHeQrJZw1UDzepRIsDN7qmpakqysIYgfSAAAAAAAAAq4t8Kw0RAtTUpNfwASoBKQEoKEgBAZhsSZcblgYuH7pEEOJyScjXOwqTgPf/1EZAFn5oshXoAAMASBHvV4EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAChIAQFFkQ4n/jfY3PH6x3frs72jiuHqg4n4G/sbwAefP2fvWwACKEgBAQ6bIDL95jufIVIrP9yAw4LFAGOnoSeF4aYDeIUNupVZAAsoSAEB15i79775v0e00SR2OMCIfj/htIQ6L5yLIDz2JeIL3Z4ADChIAQHV8FBXRSx7OF4WQhNVLmIZMWu+CxhpTwKB9o6vZH1VEQANIw8AwCNIqyG9OAEwAS8BOChIAQEd/hNLh8OcE5F41yXoDrcOSaAR2VcoioCbYDYiQsjpogAOIw0Av6vj6vKYATIBMQE4KEgBAcOM729jB3UlyK8YQm/OT/qVo6hO/YLRiXwDjrs43SpJAA0jDQC/Tiyv3dgBNAEzATgoSAEBZ1TS5e9chRdMowBHGRp30AAOKgzzJFGFAB1TzzYnNpUADCMNAL7C4h7SOAE2ATUBOChIAQElHnu+b6vYVBLfLOxOLtoS3Rn2yyzIJzgj0pt0CGwkQQALIl/ewF9A2YOKLu6HhpXAfcnikg2+iqkjjDeQwcKYeNtbE/tQgB4y6WAwAAE8VTD1nBwBOAE3KEgBAeH/QN6ikr6QxvxUJ/n8h2z12sJ5duoxDvQ/cHio3hVaAAQoSAEBsg42o7NqTN7mARBsZC6QcYsKWNryAHU9uzGJ+Va0lLYAAShIAQFQeG7Lea1rLnX2IX+nAC9csA/3isuuK3g0ytM3UFt1BAABAhG45I37Sg7rsAQBPAE7AB1DuaygAlB3XYARlU/EAAgCJYNqUgvrZXj+3BtSkF+royV2wAgBPQE9AgEgAT8BPgAVv////7y9GpSiABAAFb4AAAO8s2cNwVVQAaCbx6mHAAAAAAQBAiZkTwAAAAAA/////wAAAAAAAAAAZd3U9QAAKuLfGgWAAAAq4t8aBYUUctqLAAdbtwImZEwCJhzexAAAADAAAAAKq+c3rgFBAJgAACri3wrDRQImZE6OFkVwigTn2qmBBkuTBibGHb+QtGgEiNyG/KoVuVm78KFJGE/ZkOY16a2fK5wcOTcvyAZQ+9cs1xQ0lfApWG/k"; + everscale_types::boc::BocRepr::decode_base64(block).unwrap() + } + + fn get_default_block_id() -> BlockId { + BlockId::default() + } +} diff --git a/core/src/block_strider/state.rs b/core/src/block_strider/state.rs new file mode 100644 index 000000000..f6eef8363 --- /dev/null +++ b/core/src/block_strider/state.rs @@ -0,0 +1,21 @@ +use everscale_types::models::BlockId; + +pub trait BlockStriderState: Send + Sync + 'static { + fn load_last_traversed_master_block_id(&self) -> BlockId; + fn is_traversed(&self, block_id: &BlockId) -> bool; + fn commit_traversed(&self, block_id: BlockId); +} + +impl BlockStriderState for Box { + fn load_last_traversed_master_block_id(&self) -> BlockId { + ::load_last_traversed_master_block_id(self) + } + + fn is_traversed(&self, block_id: &BlockId) -> bool { + ::is_traversed(self, block_id) + } + + fn commit_traversed(&self, block_id: BlockId) { + ::commit_traversed(self, block_id); + } +} diff --git a/core/src/block_strider/subscriber.rs b/core/src/block_strider/subscriber.rs new file mode 100644 index 000000000..88bfa3f8b --- /dev/null +++ b/core/src/block_strider/subscriber.rs @@ -0,0 +1,36 @@ +use everscale_types::models::Block; +use futures_util::future; +use std::future::Future; + +pub trait BlockSubscriber: Send + Sync + 'static { + type HandleBlockFut: Future> + Send + 'static; + + fn handle_block(&self, block: &Block) -> Self::HandleBlockFut; +} + +impl BlockSubscriber for Box { + type HandleBlockFut = T::HandleBlockFut; + + fn handle_block(&self, block: &Block) -> Self::HandleBlockFut { + ::handle_block(self, block) + } +} + +pub struct FanoutBlockSubscriber { + pub left: T1, + pub right: T2, +} + +impl BlockSubscriber for FanoutBlockSubscriber { + type HandleBlockFut = future::BoxFuture<'static, anyhow::Result<()>>; + + fn handle_block(&self, block: &Block) -> Self::HandleBlockFut { + let left = self.left.handle_block(block); + let right = self.right.handle_block(block); + + Box::pin(async move { + let (l, r) = future::join(left, right).await; + l.and(r) + }) + } +}