pub fn load_unprocessed_operations(&self) -> QueryResult<Vec<Operation>> {
        let raw_ops: Vec<(StoredOperation, Option<ETHBinding>)> =
            self.0.conn().transaction(|| {
                operations::table
                    .left_join(eth_ops_binding::table.on(operations::id.eq(eth_ops_binding::op_id)))
                    .filter(operations::confirmed.eq(false))
                    .order(operations::id.asc())
                    .load(self.0.conn())
            })?;

        let operations: Vec<Operation> = raw_ops
            .into_iter()
            .filter_map(|(raw_op, maybe_binding)| {
                // We are only interested in operations unknown to `eth_operations` table.
                if maybe_binding.is_some() {
                    None
                } else {
                    Some(raw_op.into_op(self.0).expect("Can't convert the operation"))
                }
            })
            .collect();

        Ok(operations)
    }
/// Loads the operations which were stored in `operations` table, but not
/// in the `eth_operations`. This method is intended to be used after relaunch
/// to synchronize `eth_sender` state, as operations are sent to the `eth_sender`
/// only once.
Loads the operations which were stored in `operations` table, but not
in the `eth_operations`. This method is intended to be used after relaunch
to synchronize `eth_sender` state, as operations are sent to the `eth_sender`
only once.
Loads the operations which were stored in ` operations ` table but not in the ` eth_operations ` . This method is intended to be used after relaunch to synchronize ` eth_sender ` state as operations are sent to the ` eth_sender ` only once .
pub fn load_unprocessed_operations(&self) -> QueryResult<Vec<Operation>> {
        let raw_ops: Vec<(StoredOperation, Option<ETHBinding>)> =
            self.0.conn().transaction(|| {
                operations::table
                    .left_join(eth_ops_binding::table.on(operations::id.eq(eth_ops_binding::op_id)))
                    .filter(operations::confirmed.eq(false))
                    .order(operations::id.asc())
                    .load(self.0.conn())
            })?;
        let operations: Vec<Operation> = raw_ops
            .into_iter()
            .filter_map(|(raw_op, maybe_binding)| {
                // We are only interested in operations unknown to `eth_operations` table.
                if maybe_binding.is_some() {
                    None
                } else {
                    Some(raw_op.into_op(self.0).expect("Can't convert the operation"))
                }
            })
            .collect();
        Ok(operations)
    }
pub fn load_unprocessed_operations ( & self ) -> QueryResult < Vec < Operation > > { let raw_ops : Vec < ( StoredOperation , Option < ETHBinding > ) > = self . 0 . conn ( ) . transaction ( | | { operations :: table . left_join ( eth_ops_binding :: table . on ( operations :: id . eq ( eth_ops_binding :: op_id ) ) ) . filter ( operations :: confirmed . eq ( false ) ) . order ( operations :: id . asc ( ) ) . load ( self . 0 . conn ( ) ) } ) ? ; let operations : Vec < Operation > = raw_ops . into_iter ( ) . filter_map ( | ( raw_op , maybe_binding ) | { // We are only interested in operations unknown to `eth_operations` table. if maybe_binding . is_some ( ) { None } else { Some ( raw_op . into_op ( self . 0 ) . expect ( " " ) ) } } ) . collect ( ) ; Ok ( operations ) }
Loads the operations which were stored in `operations` table, but not
in the `eth_operations`.
Loads the operations which were stored in ` operations ` table but not in the ` eth_operations ` .
&self