TxnErr<T::GraphError>,

        crate::change::MakeChangeError<T>,

) -> Result<(Vec<Hash>, Vec<Hash>), TxnErr<T::DepsError>> {

) -> Result<(Vec<Hash>, Vec<Hash>), MakeChangeError<T>> {

) -> Result<(), TxnErr<T::GraphError>> {

) -> Result<(), MakeChangeError<T>> {

    let from = txn.find_block_end(channel, e_from).unwrap();

    let from = if let Ok(from) = txn.find_block_end(channel, e_from) {
        from
    } else {
        return Err(MakeChangeError::InvalidChange)
    };

) -> Result<(), TxnErr<T::GraphError>> {

) -> Result<(), MakeChangeError<T>> {

    let mut to = txn.find_block(channel, to_pos).unwrap();

    let mut to = if let Ok(to) = txn.find_block(channel, to_pos) {
        to
    } else {
        return Err(MakeChangeError::InvalidChange)
    };

#[derive(Error)]
pub enum MakeChangeError<T: GraphTxnT> {
    #[error(transparent)]
    Graph(#[from] TxnErr<<T as GraphTxnT>::GraphError>),
    #[error("Invalid change")]
    InvalidChange,
}
impl<T: GraphTxnT> std::fmt::Debug for MakeChangeError<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            MakeChangeError::Graph(e) => std::fmt::Debug::fmt(e, fmt),
            MakeChangeError::InvalidChange => std::fmt::Debug::fmt("InvalidChange", fmt),
        }
    }
}

    ) -> Result<Self, TxnErr<T::DepsError>> {

    ) -> Result<Self, MakeChangeError<T>> {

}
#[derive(Debug, Error)]
pub enum TextDeErrorDeps<T: GraphTxnT> {
    #[error(transparent)]
    TextDe(#[from] TextDeError),
    #[error(transparent)]
    MakeChange(#[from]MakeChangeError<T>),

    ) -> Result<Self, TextDeError> {

    ) -> Result<Self, TextDeErrorDeps<T>> {

            dependencies(txn, &channel.read(), change.hashed.changes.iter()).unwrap();

            dependencies(txn, &channel.read(), change.hashed.changes.iter())?;

    MakeChange(crate::change::MakeChangeError<T>),

            ApplyError::MakeChange(e) => std::fmt::Debug::fmt(e, fmt),

            ApplyError::MakeChange(e) => std::fmt::Display::fmt(e, fmt),

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> From<crate::change::MakeChangeError<T>>
    for ApplyError<C, T>
{
    fn from(err: crate::change::MakeChangeError<T>) -> Self {
        ApplyError::MakeChange(err)
    }
}