move MainPod layouting to mainpod (#196)

* move MainPod layouting to mainpod

* wip

* use MerkleClaimAndProof in merkle circuit set_targets

* fix empty mt proof

src/backends/plonky2/mock/mainpod.rs

@@ -1,24 +1,28 @@
+//
+// MainPod
+//
+
 use std::{any::Any, fmt};
 
 use anyhow::{anyhow, Result};
-// use base64::prelude::*;
-use plonky2::{hash::poseidon::PoseidonHash, plonk::config::Hasher};
 
+// use base64::prelude::*;
 // use serde::{Deserialize, Serialize};
+use crate::backends::plonky2::mainpod::process_private_statements_operations;
 use crate::{
-    backends::plonky2::primitives::merkletree,
+    backends::plonky2::{
+        mainpod::{
+            extract_merkle_proofs, hash_statements, layout_statements, normalize_statement,
+            process_public_statements_operations, Operation, Statement,
+        },
+        primitives::merkletree::MerkleClaimAndProof,
+    },
     middleware::{
-        self, hash_str, AnchoredKey, Hash, MainPodInputs, NativeOperation, NativePredicate,
-        NonePod, OperationType, Params, Pod, PodId, PodProver, PodType, Predicate, StatementArg,
-        ToFields, KEY_TYPE, SELF,
+        self, hash_str, AnchoredKey, MainPodInputs, NativePredicate, Params, Pod, PodId, PodProver,
+        Predicate, StatementArg, KEY_TYPE, SELF,
     },
 };
 
-mod operation;
-mod statement;
-pub use operation::*;
-pub use statement::*;
-
 pub struct MockProver {}
 
 impl PodProver for MockProver {
@@ -111,15 +115,6 @@ fn fmt_statement_index(
     Ok(())
 }
 
-pub fn fill_pad<T: Clone>(v: &mut Vec<T>, pad_value: T, len: usize) {
-    if v.len() > len {
-        panic!("length exceeded");
-    }
-    while v.len() < len {
-        v.push(pad_value.clone());
-    }
-}
-
 /// Inputs are sorted as:
 /// - SignedPods
 /// - MainPods
@@ -136,267 +131,21 @@ impl MockMainPod {
     fn offset_public_statements(&self) -> usize {
         self.offset_input_statements() + self.params.max_priv_statements()
     }
-    fn pad_statement(params: &Params, s: &mut Statement) {
-        fill_pad(&mut s.1, StatementArg::None, params.max_statement_args)
-    }
-
-    /// Returns the statements from the given MainPodInputs, padding to the
-    /// respective max lengths defined at the given Params.
-    pub(crate) fn layout_statements(params: &Params, inputs: &MainPodInputs) -> Vec<Statement> {
-        let mut statements = Vec::new();
-
-        // Input signed pods region
-        let none_sig_pod_box: Box<dyn Pod> = Box::new(NonePod {});
-        let none_sig_pod = none_sig_pod_box.as_ref();
-        assert!(inputs.signed_pods.len() <= params.max_input_signed_pods);
-        for i in 0..params.max_input_signed_pods {
-            let pod = inputs.signed_pods.get(i).unwrap_or(&none_sig_pod);
-            let sts = pod.pub_statements();
-            assert!(sts.len() <= params.max_signed_pod_values);
-            for j in 0..params.max_signed_pod_values {
-                let mut st = sts
-                    .get(j)
-                    .unwrap_or(&middleware::Statement::None)
-                    .clone()
-                    .into();
-                Self::pad_statement(params, &mut st);
-                statements.push(st);
-            }
-        }
-
-        // Input main pods region
-        let none_main_pod_box: Box<dyn Pod> = Box::new(NonePod {});
-        let none_main_pod = none_main_pod_box.as_ref();
-        assert!(inputs.main_pods.len() <= params.max_input_main_pods);
-        for i in 0..params.max_input_main_pods {
-            let pod = inputs.main_pods.get(i).copied().unwrap_or(none_main_pod);
-            let sts = pod.pub_statements();
-            assert!(sts.len() <= params.max_public_statements);
-            for j in 0..params.max_public_statements {
-                let mut st = sts
-                    .get(j)
-                    .unwrap_or(&middleware::Statement::None)
-                    .clone()
-                    .into();
-                Self::pad_statement(params, &mut st);
-                statements.push(st);
-            }
-        }
-
-        // Input statements
-        assert!(inputs.statements.len() <= params.max_priv_statements());
-        for i in 0..params.max_priv_statements() {
-            let mut st = inputs
-                .statements
-                .get(i)
-                .unwrap_or(&middleware::Statement::None)
-                .clone()
-                .into();
-            Self::pad_statement(params, &mut st);
-            statements.push(st);
-        }
-
-        // Public statements
-        assert!(inputs.public_statements.len() < params.max_public_statements);
-        let mut type_st = middleware::Statement::ValueOf(
-            AnchoredKey::from((SELF, KEY_TYPE)),
-            middleware::Value::from(PodType::MockMain),
-        )
-        .into();
-        Self::pad_statement(params, &mut type_st);
-        statements.push(type_st);
-
-        for i in 0..(params.max_public_statements - 1) {
-            let mut st = inputs
-                .public_statements
-                .get(i)
-                .unwrap_or(&middleware::Statement::None)
-                .clone()
-                .into();
-            Self::pad_statement(params, &mut st);
-            statements.push(st);
-        }
-
-        statements
-    }
-
-    /// Extracts and pads Merkle proofs from Contains/NotContains ops.
-    pub(crate) fn extract_merkle_proofs(
-        params: &Params,
-        operations: &[middleware::Operation],
-    ) -> Result<Vec<MerkleClaimAndProof>> {
-        let mut merkle_proofs = operations
-            .iter()
-            .flat_map(|op| match op {
-                middleware::Operation::ContainsFromEntries(
-                    middleware::Statement::ValueOf(_, root),
-                    middleware::Statement::ValueOf(_, key),
-                    middleware::Statement::ValueOf(_, value),
-                    pf,
-                ) => Some(MerkleClaimAndProof::try_from_middleware(
-                    params,
-                    &root.raw(),
-                    &key.raw(),
-                    Some(&value.raw()),
-                    pf,
-                )),
-                middleware::Operation::NotContainsFromEntries(
-                    middleware::Statement::ValueOf(_, root),
-                    middleware::Statement::ValueOf(_, key),
-                    pf,
-                ) => Some(MerkleClaimAndProof::try_from_middleware(
-                    params,
-                    &root.raw(),
-                    &key.raw(),
-                    None,
-                    pf,
-                )),
-                _ => None,
-            })
-            .collect::<Result<Vec<_>>>()?;
-        if merkle_proofs.len() > params.max_merkle_proofs {
-            Err(anyhow!(
-                "The number of required Merkle proofs ({}) exceeds the maximum number ({}).",
-                merkle_proofs.len(),
-                params.max_merkle_proofs
-            ))
-        } else {
-            fill_pad(
-                &mut merkle_proofs,
-                MerkleClaimAndProof::empty(params.max_depth_mt_gadget),
-                params.max_merkle_proofs,
-            );
-            Ok(merkle_proofs)
-        }
-    }
-
-    fn find_op_arg(
-        statements: &[Statement],
-        op_arg: &middleware::Statement,
-    ) -> Result<OperationArg> {
-        match op_arg {
-            middleware::Statement::None => Ok(OperationArg::None),
-            _ => statements
-                .iter()
-                .enumerate()
-                .find_map(|(i, s)| {
-                    (&middleware::Statement::try_from(s.clone()).ok()? == op_arg).then_some(i)
-                })
-                .map(OperationArg::Index)
-                .ok_or(anyhow!(
-                    "Statement corresponding to op arg {} not found",
-                    op_arg
-                )),
-        }
-    }
-
-    fn find_op_aux(
-        merkle_proofs: &[MerkleClaimAndProof],
-        op_aux: &middleware::OperationAux,
-    ) -> Result<OperationAux> {
-        match op_aux {
-            middleware::OperationAux::None => Ok(OperationAux::None),
-            middleware::OperationAux::MerkleProof(pf_arg) => merkle_proofs
-                .iter()
-                .enumerate()
-                .find_map(|(i, pf)| {
-                    pf.clone()
-                        .try_into()
-                        .ok()
-                        .and_then(|mid_pf: merkletree::MerkleProof| {
-                            (&mid_pf == pf_arg).then_some(i)
-                        })
-                })
-                .map(OperationAux::MerkleProofIndex)
-                .ok_or(anyhow!(
-                    "Merkle proof corresponding to op arg {} not found",
-                    op_aux
-                )),
-        }
-    }
-
-    pub(crate) fn process_private_statements_operations(
-        params: &Params,
-        statements: &[Statement],
-        merkle_proofs: &[MerkleClaimAndProof],
-        input_operations: &[middleware::Operation],
-    ) -> Result<Vec<Operation>> {
-        let mut operations = Vec::new();
-        for i in 0..params.max_priv_statements() {
-            let op = input_operations
-                .get(i)
-                .unwrap_or(&middleware::Operation::None)
-                .clone();
-            let mid_args = op.args();
-            let mut args = mid_args
-                .iter()
-                .map(|mid_arg| Self::find_op_arg(statements, mid_arg))
-                .collect::<Result<Vec<_>>>()?;
-
-            let mid_aux = op.aux();
-            let aux = Self::find_op_aux(merkle_proofs, &mid_aux)?;
-
-            Self::pad_operation_args(params, &mut args);
-            operations.push(Operation(op.op_type(), args, aux));
-        }
-        Ok(operations)
-    }
-
-    // NOTE: In this implementation public statements are always copies from
-    // previous statements, so we fill in the operations accordingly.
-    /// This method assumes that the given `statements` array has been padded to
-    /// `params.max_statements`.
-    pub(crate) fn process_public_statements_operations(
-        params: &Params,
-        statements: &[Statement],
-        mut operations: Vec<Operation>,
-    ) -> Result<Vec<Operation>> {
-        let offset_public_statements = statements.len() - params.max_public_statements;
-        operations.push(Operation(
-            OperationType::Native(NativeOperation::NewEntry),
-            vec![],
-            OperationAux::None,
-        ));
-        for i in 0..(params.max_public_statements - 1) {
-            let st = &statements[offset_public_statements + i + 1];
-            let mut op = if st.is_none() {
-                Operation(
-                    OperationType::Native(NativeOperation::None),
-                    vec![],
-                    OperationAux::None,
-                )
-            } else {
-                let mid_arg = st.clone();
-                Operation(
-                    OperationType::Native(NativeOperation::CopyStatement),
-                    vec![Self::find_op_arg(statements, &mid_arg.try_into()?)?],
-                    OperationAux::None,
-                )
-            };
-            fill_pad(&mut op.1, OperationArg::None, params.max_operation_args);
-            operations.push(op);
-        }
-        Ok(operations)
-    }
 
     pub fn new(params: &Params, inputs: MainPodInputs) -> Result<Self> {
-        // TODO: Figure out a way to handle public statements.  For example, in the public slots
-        // use copy operations taking the private statements that need to be public.  We may change
-        // the MainPodInputs type to accommodate for that.
         // TODO: Insert a new public statement of ValueOf with `key=KEY_TYPE,
         // value=PodType::MockMainPod`
-        let statements = Self::layout_statements(params, &inputs);
+        let statements = layout_statements(params, &inputs);
         // Extract Merkle proofs and pad.
-        let merkle_proofs = Self::extract_merkle_proofs(params, inputs.operations)?;
+        let merkle_proofs = extract_merkle_proofs(params, inputs.operations)?;
 
-        let operations = Self::process_private_statements_operations(
+        let operations = process_private_statements_operations(
             params,
             &statements,
             &merkle_proofs,
             inputs.operations,
         )?;
-        let operations =
-            Self::process_public_statements_operations(params, &statements, operations)?;
+        let operations = process_public_statements_operations(params, &statements, operations)?;
 
         let public_statements =
             statements[statements.len() - params.max_public_statements..].to_vec();
@@ -417,10 +166,6 @@ impl MockMainPod {
         })
     }
 
-    fn pad_operation_args(params: &Params, args: &mut Vec<OperationArg>) {
-        fill_pad(args, OperationArg::None, params.max_operation_args)
-    }
-
     // pub fn deserialize(serialized: String) -> Result<Self> {
     //     let proof = String::from_utf8(BASE64_STANDARD.decode(&serialized)?)
     //         .map_err(|e| anyhow::anyhow!("Invalid base64 encoding: {}", e))?;
@@ -431,14 +176,6 @@ impl MockMainPod {
     // }
 }
 
-pub fn hash_statements(statements: &[Statement], _params: &Params) -> middleware::Hash {
-    let field_elems = statements
-        .iter()
-        .flat_map(|statement| statement.clone().to_fields(_params))
-        .collect::<Vec<_>>();
-    Hash(PoseidonHash::hash_no_pad(&field_elems).elements)
-}
-
 impl Pod for MockMainPod {
     fn verify(&self) -> Result<()> {
         // 1. TODO: Verify input pods
@@ -533,23 +270,7 @@ impl Pod for MockMainPod {
             .iter()
             .skip(self.offset_public_statements())
             .cloned()
-            .map(|statement| {
-                Statement(
-                    statement.0.clone(),
-                    statement
-                        .1
-                        .iter()
-                        .map(|sa| match &sa {
-                            StatementArg::Key(AnchoredKey { pod_id, key }) if *pod_id == SELF => {
-                                StatementArg::Key(AnchoredKey::new(self.id(), key.clone()))
-                            }
-                            _ => sa.clone(),
-                        })
-                        .collect(),
-                )
-                .try_into()
-                .unwrap()
-            })
+            .map(|statement| normalize_statement(&statement, self.id()))
             .collect()
     }
 

src/backends/plonky2/mock/mainpod/operation.rs

@@ -1,218 +0,0 @@
-use std::{fmt, iter};
-
-use anyhow::{anyhow, Result};
-use plonky2::field::types::Field;
-
-// use serde::{Deserialize, Serialize};
-use crate::{
-    backends::plonky2::{
-        mock::mainpod::Statement,
-        primitives::merkletree::{self},
-    },
-    middleware::{
-        self, Hash, OperationType, Params, RawValue, ToFields, EMPTY_HASH, EMPTY_VALUE, F,
-    },
-};
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum OperationArg {
-    None,
-    Index(usize),
-}
-
-impl ToFields for OperationArg {
-    fn to_fields(&self, _params: &Params) -> Vec<F> {
-        let f = match self {
-            Self::None => F::ZERO,
-            Self::Index(i) => F::from_canonical_usize(*i),
-        };
-        vec![f]
-    }
-}
-
-impl OperationArg {
-    pub fn is_none(&self) -> bool {
-        matches!(self, OperationArg::None)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum OperationAux {
-    None,
-    MerkleProofIndex(usize),
-}
-
-impl ToFields for OperationAux {
-    fn to_fields(&self, _params: &Params) -> Vec<F> {
-        let f = match self {
-            Self::None => F::ZERO,
-            Self::MerkleProofIndex(i) => F::from_canonical_usize(*i),
-        };
-        vec![f]
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct MerkleClaimAndProof {
-    pub enabled: bool,
-    pub root: Hash,
-    pub key: RawValue,
-    pub value: RawValue,
-    pub existence: bool,
-    pub siblings: Vec<Hash>,
-    pub case_ii_selector: bool,
-    pub other_key: RawValue,
-    pub other_value: RawValue,
-}
-
-impl MerkleClaimAndProof {
-    pub fn empty(max_depth: usize) -> Self {
-        Self {
-            enabled: false,
-            root: EMPTY_HASH,
-            key: RawValue::from(1),
-            value: EMPTY_VALUE,
-            existence: false,
-            siblings: iter::repeat(EMPTY_HASH).take(max_depth).collect(),
-            case_ii_selector: false,
-            other_key: EMPTY_VALUE,
-            other_value: EMPTY_VALUE,
-        }
-    }
-    pub fn try_from_middleware(
-        params: &Params,
-        root: &RawValue,
-        key: &RawValue,
-        value: Option<&RawValue>,
-        mid_mp: &merkletree::MerkleProof,
-    ) -> Result<Self> {
-        if mid_mp.siblings.len() > params.max_depth_mt_gadget {
-            Err(anyhow!(
-                "Number of siblings ({}) exceeds maximum depth ({})",
-                mid_mp.siblings.len(),
-                params.max_depth_mt_gadget
-            ))
-        } else {
-            let (other_key, other_value) = mid_mp.other_leaf.unwrap_or((EMPTY_VALUE, EMPTY_VALUE));
-            Ok(Self {
-                enabled: true,
-                root: (*root).into(),
-                key: *key,
-                value: value.cloned().unwrap_or(EMPTY_VALUE),
-                existence: mid_mp.existence,
-                siblings: mid_mp
-                    .siblings
-                    .iter()
-                    .cloned()
-                    .chain(iter::repeat(EMPTY_HASH))
-                    .take(params.max_depth_mt_gadget)
-                    .collect(),
-                case_ii_selector: mid_mp.other_leaf.is_some(),
-                other_key,
-                other_value,
-            })
-        }
-    }
-}
-
-impl TryFrom<MerkleClaimAndProof> for merkletree::MerkleProof {
-    type Error = anyhow::Error;
-    fn try_from(mp: MerkleClaimAndProof) -> Result<Self> {
-        if !mp.enabled {
-            return Err(anyhow!("Not a valid Merkle proof."));
-        }
-        let existence = mp.existence;
-        let other_leaf = if mp.case_ii_selector {
-            Some((mp.other_key, mp.other_value))
-        } else {
-            None
-        };
-        // Trim padding (if any).
-        let siblings = mp
-            .siblings
-            .into_iter()
-            .rev()
-            .skip_while(|s| s == &EMPTY_HASH)
-            .collect::<Vec<_>>()
-            .into_iter()
-            .rev()
-            .collect();
-        Ok(merkletree::MerkleProof {
-            existence,
-            siblings,
-            other_leaf,
-        })
-    }
-}
-
-impl fmt::Display for MerkleClaimAndProof {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match merkletree::MerkleProof::try_from(self.clone()) {
-            Err(_) => write!(f, "∅"),
-            Ok(mp) => mp.fmt(f),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct Operation(pub OperationType, pub Vec<OperationArg>, pub OperationAux);
-
-impl Operation {
-    pub fn op_type(&self) -> OperationType {
-        self.0.clone()
-    }
-    pub fn args(&self) -> &[OperationArg] {
-        &self.1
-    }
-    pub fn aux(&self) -> &OperationAux {
-        &self.2
-    }
-    pub fn deref(
-        &self,
-        statements: &[Statement],
-        merkle_proofs: &[MerkleClaimAndProof],
-    ) -> Result<crate::middleware::Operation> {
-        let deref_args = self
-            .1
-            .iter()
-            .flat_map(|arg| match arg {
-                OperationArg::None => None,
-                OperationArg::Index(i) => Some(statements[*i].clone().try_into()),
-            })
-            .collect::<Result<Vec<_>>>()?;
-        let deref_aux = match self.2 {
-            OperationAux::None => Ok(crate::middleware::OperationAux::None),
-            OperationAux::MerkleProofIndex(i) => merkle_proofs
-                .get(i)
-                .cloned()
-                .ok_or(anyhow!("Missing Merkle proof index {}", i))
-                .and_then(|mp| {
-                    mp.try_into()
-                        .map(crate::middleware::OperationAux::MerkleProof)
-                }),
-        }?;
-        middleware::Operation::op(self.0.clone(), &deref_args, &deref_aux)
-    }
-}
-
-impl fmt::Display for Operation {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?} ", self.0)?;
-        for (i, arg) in self.1.iter().enumerate() {
-            if f.alternate() || !arg.is_none() {
-                if i != 0 {
-                    write!(f, " ")?;
-                }
-                match arg {
-                    OperationArg::None => write!(f, "none")?,
-                    OperationArg::Index(i) => write!(f, "{:02}", i)?,
-                }
-            }
-        }
-        match self.2 {
-            OperationAux::None => (),
-            OperationAux::MerkleProofIndex(i) => write!(f, " merkle_proof_{:02}", i)?,
-        }
-        Ok(())
-    }
-}

src/backends/plonky2/mock/mainpod/statement.rs

@@ -1,130 +0,0 @@
-use std::fmt;
-
-use anyhow::{anyhow, Result};
-
-// use serde::{Deserialize, Serialize};
-use crate::middleware::{
-    self, NativePredicate, Params, Predicate, StatementArg, ToFields, WildcardValue,
-};
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct Statement(pub Predicate, pub Vec<StatementArg>);
-
-impl Statement {
-    pub fn is_none(&self) -> bool {
-        self.0 == Predicate::Native(NativePredicate::None)
-    }
-    pub fn predicate(&self) -> Predicate {
-        self.0.clone()
-    }
-    /// Argument method. Trailing Nones are filtered out.
-    pub fn args(&self) -> Vec<StatementArg> {
-        let maybe_last_arg_index = (0..self.1.len()).rev().find(|i| !self.1[*i].is_none());
-        match maybe_last_arg_index {
-            None => vec![],
-            Some(i) => self.1[0..i + 1].to_vec(),
-        }
-    }
-}
-
-impl ToFields for Statement {
-    fn to_fields(&self, _params: &Params) -> Vec<middleware::F> {
-        let mut fields = self.0.to_fields(_params);
-        fields.extend(self.1.iter().flat_map(|arg| arg.to_fields(_params)));
-        fields
-    }
-}
-
-impl TryFrom<Statement> for middleware::Statement {
-    type Error = anyhow::Error;
-    fn try_from(s: Statement) -> Result<Self> {
-        type S = middleware::Statement;
-        type NP = NativePredicate;
-        type SA = StatementArg;
-        let proper_args = s.args();
-        let args = (
-            proper_args.first().cloned(),
-            proper_args.get(1).cloned(),
-            proper_args.get(2).cloned(),
-        );
-        Ok(match s.0 {
-            Predicate::Native(np) => match (np, args, proper_args.len()) {
-                (NP::None, _, 0) => S::None,
-                (NP::ValueOf, (Some(SA::Key(ak)), Some(SA::Literal(v)), None), 2) => {
-                    S::ValueOf(ak, v)
-                }
-                (NP::Equal, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), None), 2) => {
-                    S::Equal(ak1, ak2)
-                }
-                (NP::NotEqual, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), None), 2) => {
-                    S::NotEqual(ak1, ak2)
-                }
-                (NP::Gt, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), None), 2) => S::Gt(ak1, ak2),
-                (NP::Lt, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), None), 2) => S::Lt(ak1, ak2),
-                (NP::Contains, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), Some(SA::Key(ak3))), 3) => {
-                    S::Contains(ak1, ak2, ak3)
-                }
-                (NP::NotContains, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), None), 2) => {
-                    S::NotContains(ak1, ak2)
-                }
-                (NP::SumOf, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), Some(SA::Key(ak3))), 3) => {
-                    S::SumOf(ak1, ak2, ak3)
-                }
-                (
-                    NP::ProductOf,
-                    (Some(SA::Key(ak1)), Some(SA::Key(ak2)), Some(SA::Key(ak3))),
-                    3,
-                ) => S::ProductOf(ak1, ak2, ak3),
-                (NP::MaxOf, (Some(SA::Key(ak1)), Some(SA::Key(ak2)), Some(SA::Key(ak3))), 3) => {
-                    S::MaxOf(ak1, ak2, ak3)
-                }
-                _ => Err(anyhow!("Ill-formed statement expression {:?}", s))?,
-            },
-            Predicate::Custom(cpr) => {
-                let vs: Vec<WildcardValue> = proper_args
-                    .into_iter()
-                    .filter_map(|arg| match arg {
-                        SA::None => None,
-                        SA::WildcardLiteral(v) => Some(v),
-                        _ => unreachable!(),
-                    })
-                    .collect();
-                S::Custom(cpr, vs)
-            }
-            Predicate::BatchSelf(_) => {
-                unreachable!()
-            }
-        })
-    }
-}
-
-impl From<middleware::Statement> for Statement {
-    fn from(s: middleware::Statement) -> Self {
-        match s.predicate() {
-            middleware::Predicate::Native(c) => Statement(
-                middleware::Predicate::Native(c),
-                s.args().into_iter().collect(),
-            ),
-            middleware::Predicate::Custom(cpr) => Statement(
-                middleware::Predicate::Custom(cpr),
-                s.args().into_iter().collect(),
-            ),
-            middleware::Predicate::BatchSelf(_) => unreachable!(),
-        }
-    }
-}
-
-impl fmt::Display for Statement {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?} ", self.0)?;
-        for (i, arg) in self.1.iter().enumerate() {
-            if f.alternate() || !arg.is_none() {
-                if i != 0 {
-                    write!(f, " ")?;
-                }
-                write!(f, "{}", arg)?;
-            }
-        }
-        Ok(())
-    }
-}