Top down discussion

Cargo.toml

@@ -9,6 +9,7 @@ members = [
   "fendermint/testing",
   "fendermint/testing/*-test",
   "fendermint/vm/*",
+  "fendermint/ipc",
 ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -56,7 +57,7 @@ serde_tuple = "0.5"
 serde_with = "2.3" 
 tempfile = "3.3" 
 thiserror = "1" 
-tokio = {version = "1", features = ["rt-multi-thread", "macros"]} 
+tokio = {version = "1", features = ["rt-multi-thread", "macros", "time"]}
 tracing = "0.1" 
 tracing-subscriber = "0.3" 
 
@@ -104,3 +105,4 @@ tendermint-proto = { version = "0.31" }
 
 # Using the IPC SDK without the `fil-actor` feature so as not to depend on the actor `Runtime`.
 ipc-sdk = { git = "https://github.com/consensus-shipyard/ipc-actors.git", default-features = false, branch = "main" }
+ipc-gateway = { git = "https://github.com/consensus-shipyard/ipc-actors.git", features = [] }

fendermint/app/Cargo.toml

@@ -41,6 +41,7 @@ fendermint_vm_core = { path = "../vm/core" }
 fendermint_vm_interpreter = { path = "../vm/interpreter", features = ["bundle"] }
 fendermint_vm_message = { path = "../vm/message" }
 fendermint_vm_genesis = { path = "../vm/genesis" }
+fendermint_ipc = { path = "../ipc" }
 
 cid = { workspace = true }
 fvm = { workspace = true }

fendermint/app/src/app.rs

@@ -6,8 +6,11 @@ use std::sync::{Arc, Mutex};
 
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
+use bytes::Bytes;
 use cid::Cid;
 use fendermint_abci::{AbciResult, Application};
+use fendermint_ipc::pof::ProofOfFinality;
+use fendermint_ipc::IPCMessage;
 use fendermint_storage::{
     Codec, Encode, KVCollection, KVRead, KVReadable, KVStore, KVWritable, KVWrite,
 };
@@ -24,6 +27,7 @@ use fendermint_vm_interpreter::signed::InvalidSignature;
 use fendermint_vm_interpreter::{
     CheckInterpreter, ExecInterpreter, GenesisInterpreter, QueryInterpreter,
 };
+use fendermint_vm_message::chain::ChainMessage;
 use fvm::engine::MultiEngine;
 use fvm_ipld_blockstore::Blockstore;
 use fvm_shared::chainid::ChainID;
@@ -125,6 +129,8 @@ where
     ///
     /// Zero means unlimited.
     state_hist_size: u64,
+    /// The top down parent finality.
+    parent_finality: ProofOfFinality,
 }
 
 impl<DB, SS, S, I> App<DB, SS, S, I>
@@ -157,6 +163,7 @@ where
             interpreter: Arc::new(interpreter),
             exec_state: Arc::new(Mutex::new(None)),
             check_state: Arc::new(tokio::sync::Mutex::new(None)),
+            parent_finality: (),
         };
         app.init_committed_state()?;
         Ok(app)
@@ -291,6 +298,36 @@ where
         let state = self.committed_state()?;
         Ok((state.state_params, state.block_height))
     }
+
+    async fn verify_ipc_message(&self, ipc_message: IPCMessage) -> bool {
+        match ipc_message {
+            IPCMessage::TopDown(finality) => self.parent_finality.check_finality(&finality).await,
+            IPCMessage::BottomUp => unimplemented!(),
+        }
+    }
+
+    /// Verifies the list of transactions to see if they are valid. Returns true if all the txns
+    /// are valid and false if any one of the txns is invalid.
+    async fn verify_messages(&self, txns: &Vec<Bytes>) -> bool {
+        for tx in txns {
+            let is_ok = match serde_json::from_slice::<ChainMessage>(tx) {
+                Err(_) => {
+                    tracing::info!("cannot deserialized transaction: {tx:?}");
+                    continue;
+                }
+                Ok(message) => match message {
+                    ChainMessage::IPC(ipc) => self.verify_ipc_message(ipc).await,
+                    _ => continue,
+                },
+            };
+
+            if !is_ok {
+                return false;
+            }
+        }
+
+        true
+    }
 }
 
 // NOTE: The `Application` interface doesn't allow failures at the moment. The protobuf
@@ -490,6 +527,40 @@ where
         Ok(response)
     }
 
+    async fn prepare_proposal(
+        &self,
+        request: request::PrepareProposal,
+    ) -> AbciResult<response::PrepareProposal> {
+        let max_tx_bytes: usize = request.max_tx_bytes.try_into().unwrap();
+        let mut size: usize = 0;
+        let mut txs = Vec::new();
+        for tx in request.txs {
+            if size.saturating_add(tx.len()) > max_tx_bytes {
+                break;
+            }
+            size += tx.len();
+            txs.push(tx);
+        }
+
+        let proof = self.parent_finality.get_finality();
+        let bytes = serde_json::to_vec(&ChainMessage::IPC(IPCMessage::TopDown(proof)))
+            .expect("should not have failed");
+        txs.push(bytes.into());
+
+        Ok(response::PrepareProposal { txs })
+    }
+
+    async fn process_proposal(
+        &self,
+        request: request::ProcessProposal,
+    ) -> AbciResult<response::ProcessProposal> {
+        if !self.verify_messages(&request.txs).await {
+            Ok(response::ProcessProposal::Reject)
+        } else {
+            Ok(response::ProcessProposal::Accept)
+        }
+    }
+
     /// Signals the beginning of a new block, prior to any `DeliverTx` calls.
     async fn begin_block(&self, request: request::BeginBlock) -> AbciResult<response::BeginBlock> {
         let db = self.state_store_clone();

fendermint/ipc/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "fendermint_ipc"
+version = "0.1.0"
+edition = "2021"
+description = "Interfacing with IPC"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+tokio = { workspace = true }
+anyhow = { workspace = true }
+ipc-sdk = { workspace = true }
+async-trait = { workspace = true }
+tracing = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }

fendermint/ipc/src/lib.rs

@@ -0,0 +1,18 @@
+// Copyright 2022-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+//! Interfacing with IPC, provides utility functions
+
+mod message;
+mod parent;
+pub mod pof;
+
+pub use message::IPCMessage;
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    /// The number of blocks to delay reporting when creating the pof
+    chain_head_delay: u64,
+
+    /// Parent syncing cron period, in seconds
+    polling_interval: u64,
+}

fendermint/ipc/src/message.rs

@@ -0,0 +1,16 @@
+//! IPC messages
+
+use crate::pof::IPCParentFinality;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum IPCMessage {
+    TopDown(IPCParentFinality),
+    BottomUp,
+}
+
+impl From<IPCMessage> for Vec<u8> {
+    fn from(value: IPCMessage) -> Self {
+        serde_json::to_vec(&value).expect("should not happen")
+    }
+}

fendermint/ipc/src/parent.rs

@@ -0,0 +1,29 @@
+// Copyright 2022-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+//! Parent syncing related functions
+
+use async_trait::async_trait;
+
+/// Obtain the latest state information required for IPC from the parent subnet
+#[async_trait]
+pub trait ParentSyncer {
+    /// Get the latest height
+    async fn latest_height(&self) -> anyhow::Result<u64>;
+    /// Get the block hash at the target height
+    async fn block_hash(&self, height: u64) -> anyhow::Result<Vec<u8>>;
+}
+
+/// Constantly syncing with parent through polling
+pub struct PollingParentSyncer {}
+
+#[async_trait]
+impl ParentSyncer for PollingParentSyncer {
+    async fn latest_height(&self) -> anyhow::Result<u64> {
+        todo!()
+    }
+
+    async fn block_hash(&self, _height: u64) -> anyhow::Result<Vec<u8>> {
+        todo!()
+    }
+}