payjoin / rust-payjoin / 17840270211

    fn deref(&self) -> &Self::Target { &self.0 }

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.0) }

    pub fn new(db: Arc<Database>, receiver_pubkey: HpkePublicKey) -> crate::db::Result<Self> {

        let conn = db.get_connection()?;

        let session_id: i64 = conn.query_row(

            "INSERT INTO send_sessions (session_id, receiver_pubkey) VALUES (NULL, ?1) RETURNING session_id",

            params![receiver_pubkey.to_compressed_bytes()],

            |row| row.get(0),

        )?;

        Ok(Self { db, session_id: SessionId(session_id) })

    }

    pub fn from_id(db: Arc<Database>, id: SessionId) -> Self { Self { db, session_id: id } }

    fn save_event(

        &self,

        event: SenderSessionEvent,

    ) -> std::result::Result<(), Self::InternalStorageError> {

        let conn = self.db.get_connection()?;

        let event_data = serde_json::to_string(&event).map_err(Error::Serialize)?;

        conn.execute(

            "INSERT INTO send_session_events (session_id, event_data, created_at) VALUES (?1, ?2, ?3)",

            params![*self.session_id, event_data, now()],

        )?;

        Ok(())

    }

    fn load(

        &self,

    ) -> std::result::Result<Box<dyn Iterator<Item = SenderSessionEvent>>, Self::InternalStorageError>

        let conn = self.db.get_connection()?;

        let mut stmt = conn.prepare(

            "SELECT event_data FROM send_session_events WHERE session_id = ?1 ORDER BY created_at ASC",

        )?;

        let event_rows = stmt.query_map(params![*self.session_id], |row| {

            let event_data: String = row.get(0)?;

            Ok(event_data)

        })?;

        let events: Vec<SenderSessionEvent> = event_rows

            .map(|row| {

                let event_data = row.expect("Failed to read event data from database");

                serde_json::from_str::<SenderSessionEvent>(&event_data)

                    .expect("Database corruption: failed to deserialize session event")

            })

            .collect();

        Ok(Box::new(events.into_iter()))

    }

    fn close(&self) -> std::result::Result<(), Self::InternalStorageError> {

        let conn = self.db.get_connection()?;

        conn.execute(

            "UPDATE send_sessions SET completed_at = ?1 WHERE session_id = ?2",

            params![now(), *self.session_id],

        )?;

        Ok(())

    }

    pub fn new(db: Arc<Database>) -> crate::db::Result<Self> {

        let conn = db.get_connection()?;

        let session_id: i64 = conn.query_row(

            "INSERT INTO receive_sessions (session_id) VALUES (NULL) RETURNING session_id",

            [],

            |row| row.get(0),

        )?;

        Ok(Self { db, session_id: SessionId(session_id) })

    }

    pub fn from_id(db: Arc<Database>, id: SessionId) -> Self { Self { db, session_id: id } }

    fn save_event(

        &self,

        event: ReceiverSessionEvent,

    ) -> std::result::Result<(), Self::InternalStorageError> {

        let conn = self.db.get_connection()?;

        let event_data = serde_json::to_string(&event).map_err(Error::Serialize)?;

        conn.execute(

            "INSERT INTO receive_session_events (session_id, event_data, created_at) VALUES (?1, ?2, ?3)",

            params![*self.session_id, event_data, now()],

        )?;

        Ok(())

    }

    fn load(

        &self,

    ) -> std::result::Result<

        Box<dyn Iterator<Item = ReceiverSessionEvent>>,

        Self::InternalStorageError,

    > {

        let conn = self.db.get_connection()?;

        let mut stmt = conn.prepare(

            "SELECT event_data FROM receive_session_events WHERE session_id = ?1 ORDER BY created_at ASC",

        )?;

        let event_rows = stmt.query_map(params![*self.session_id], |row| {

            let event_data: String = row.get(0)?;

            Ok(event_data)

        })?;

        let events: Vec<ReceiverSessionEvent> = event_rows

            .map(|row| {

                let event_data = row.expect("Failed to read event data from database");

                serde_json::from_str::<ReceiverSessionEvent>(&event_data)

                    .expect("Database corruption: failed to deserialize session event")

            })

            .collect();

        Ok(Box::new(events.into_iter()))

    }

    fn close(&self) -> std::result::Result<(), Self::InternalStorageError> {

        let conn = self.db.get_connection()?;

        conn.execute(

            "UPDATE receive_sessions SET completed_at = ?1 WHERE session_id = ?2",

            params![now(), *self.session_id],

        )?;

        Ok(())

    }

    pub(crate) fn get_recv_session_ids(&self) -> Result<Vec<SessionId>> {

        let conn = self.get_connection()?;

        let mut stmt =

            conn.prepare("SELECT session_id FROM receive_sessions WHERE completed_at IS NULL")?;

        let session_rows = stmt.query_map([], |row| {

            let session_id: i64 = row.get(0)?;

            Ok(SessionId(session_id))

        })?;

        let mut session_ids = Vec::new();

        for session_row in session_rows {

            let session_id = session_row?;

            session_ids.push(session_id);

        Ok(session_ids)

    }

    pub(crate) fn get_send_session_ids(&self) -> Result<Vec<SessionId>> {

        let conn = self.get_connection()?;

        let mut stmt =

            conn.prepare("SELECT session_id FROM send_sessions WHERE completed_at IS NULL")?;

        let session_rows = stmt.query_map([], |row| {

            let session_id: i64 = row.get(0)?;

            Ok(SessionId(session_id))

        })?;

        let mut session_ids = Vec::new();

        for session_row in session_rows {

            let session_id = session_row?;

            session_ids.push(session_id);

        Ok(session_ids)

    }

    pub(crate) fn get_send_session_receiver_pk(

        &self,

        session_id: &SessionId,

    ) -> Result<HpkePublicKey> {

        let conn = self.get_connection()?;

        let mut stmt =

            conn.prepare("SELECT receiver_pubkey FROM send_sessions WHERE session_id = ?1")?;

        let receiver_pubkey: Vec<u8> = stmt.query_row(params![session_id.0], |row| row.get(0))?;

        Ok(HpkePublicKey::from_compressed_bytes(&receiver_pubkey).expect("Valid receiver pubkey"))

    }

    pub(crate) fn get_inactive_send_session_ids(&self) -> Result<Vec<(SessionId, u64)>> {

        let conn = self.get_connection()?;

        let mut stmt = conn.prepare(

            "SELECT session_id, completed_at FROM send_sessions WHERE completed_at IS NOT NULL",

        )?;

        let session_rows = stmt.query_map([], |row| {

            let session_id: i64 = row.get(0)?;

            let completed_at: u64 = row.get(1)?;

            Ok((SessionId(session_id), completed_at))

        })?;

        let mut session_ids = Vec::new();

        for session_row in session_rows {

            let (session_id, completed_at) = session_row?;

            session_ids.push((session_id, completed_at));

        Ok(session_ids)

    }

    pub(crate) fn get_inactive_recv_session_ids(&self) -> Result<Vec<(SessionId, u64)>> {

        let conn = self.get_connection()?;

        let mut stmt = conn.prepare(

            "SELECT session_id, completed_at FROM receive_sessions WHERE completed_at IS NOT NULL",

        )?;

        let session_rows = stmt.query_map([], |row| {

            let session_id: i64 = row.get(0)?;

            let completed_at: u64 = row.get(1)?;

            Ok((SessionId(session_id), completed_at))

        })?;

        let mut session_ids = Vec::new();

        for session_row in session_rows {

            let (session_id, completed_at) = session_row?;

            session_ids.push((session_id, completed_at));

        Ok(session_ids)

    }