Method process

fendermint/vm/interpreter/src/bytes.rs:129–164

Parse messages in the block, reject if unknown format. Pass the rest to the inner `ChainMessage` interpreter.

(&self, state: Self::State, msgs: Vec<Self::Message>)

    /// Parse messages in the block, reject if unknown format. Pass the rest to the inner `ChainMessage` interpreter.
    async fn process(&self, state: Self::State, msgs: Vec<Self::Message>) -> anyhow::Result<bool> {
        if msgs.len() > self.max_msgs {
            tracing::warn!(
                block_msgs = msgs.len(),
                "rejecting block: too many messages"
            );
            return Ok(false);
        }

        let mut chain_msgs = Vec::new();
        for msg in msgs {
            match fvm_ipld_encoding::from_slice::<ChainMessage>(&msg) {
                Err(e) => {
                    // If we cannot parse a message, then either:
                    // * The proposer is Byzantine - as an attack this isn't very effective as they could just not send a proposal and cause a timeout.
                    // * Our or the proposer node have different versions, or contain bugs
                    // We can either vote for it or not:
                    // * If we accept, we can punish the validator during block execution, and if it turns out we had a bug, we will have a consensus failure.
                    // * If we accept, then the serialization error will become visible in the transaction results through RPC.
                    // * If we reject, the majority can still accept the block, which indicates we had the bug (that way we might even panic during delivery, since we know it got voted on),
                    //   but a buggy transaction format that fails for everyone would cause liveness issues.
                    // * If we reject, then the serialization error will only be visible in the logs (and potentially earlier check_tx results).
                    tracing::warn!(
                        error = e.to_string(),
                        "failed to decode message in proposal as ChainMessage"
                    );
                    if self.reject_malformed_proposal {
                        return Ok(false);
                    }
                }
                Ok(msg) => chain_msgs.push(msg),
            }
        }

        self.inner.process(state, chain_msgs).await
    }
}

#[async_trait]