Method prepare

fendermint/vm/interpreter/src/bytes.rs:74–126

Parse messages in the mempool and pass them into the inner `ChainMessage` interpreter.

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

    /// Parse messages in the mempool and pass them into the inner `ChainMessage` interpreter.
    async fn prepare(
        &self,
        state: Self::State,
        msgs: Vec<Self::Message>,
    ) -> anyhow::Result<Vec<Self::Message>> {
        // Collect the messages to pass to the inner interpreter.
        let chain_msgs = match self.prepare_mode {
            ProposalPrepareMode::PassThrough => {
                let mut chain_msgs = Vec::new();
                for msg in msgs.iter() {
                    match fvm_ipld_encoding::from_slice::<ChainMessage>(msg) {
                        Err(e) => {
                            // This should not happen because the `CheckInterpreter` implementation below would
                            // have rejected any such user transaction.
                            tracing::warn!(
                                error = e.to_string(),
                                "failed to decode message in mempool as ChainMessage"
                            );
                        }
                        Ok(msg) => chain_msgs.push(msg),
                    }
                }
                chain_msgs
            }
            ProposalPrepareMode::AppendOnly | ProposalPrepareMode::PrependOnly => Vec::new(),
        };

        let chain_msgs = self.inner.prepare(state, chain_msgs).await?;

        let chain_msgs = chain_msgs
            .into_iter()
            .map(|msg| {
                fvm_ipld_encoding::to_vec(&msg).context("failed to encode ChainMessage as IPLD")
            })
            .collect::<anyhow::Result<Vec<Self::Message>>>()?;

        let mut all_msgs = match self.prepare_mode {
            ProposalPrepareMode::PassThrough => chain_msgs,
            ProposalPrepareMode::AppendOnly => [msgs, chain_msgs].concat(),
            ProposalPrepareMode::PrependOnly => [chain_msgs, msgs].concat(),
        };

        if all_msgs.len() > self.max_msgs {
            tracing::warn!(
                max_msgs = self.max_msgs,
                all_msgs = all_msgs.len(),
                "truncating proposal"
            );
            all_msgs.truncate(self.max_msgs);
        }

        Ok(all_msgs)
    }

    /// 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> {