feat: Add insert_transaction

src/sqlite.rs

@@ -33,13 +33,37 @@ impl ToSql for TransactionType {
     }
 }
 
-fn main() -> Result<()> {
-    let conn = initialize_db()?;
+#[derive(Debug)]
+pub enum DatabaseError {
+    SqliteError(rusqlite::Error),
+    InvalidTransactionType(String),
+    InvalidTransactionData(String),
+}
+
+impl std::error::Error for DatabaseError {}
+
+impl std::fmt::Display for DatabaseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            DatabaseError::SqliteError(e) => write!(f, "Database error: {}", e),
+            DatabaseError::InvalidTransactionType(msg) => write!(f, "Invalid transaction type: {}", msg),
+            DatabaseError::InvalidTransactionData(msg) => write!(f, "Invalid transaction data: {}", msg),
+        }
+    }
+}
+
+impl From<rusqlite::Error> for DatabaseError {
+    fn from(err: rusqlite::Error) -> DatabaseError {
+        DatabaseError::SqliteError(err)
+    }
+}
 
+fn main() -> Result<(), DatabaseError> {
+    let conn = initialize_db()?;
     Ok(())
 }
 
-fn initialize_db() -> Result<Connection, rusqlite::Error> {
+fn initialize_db() -> Result<Connection, DatabaseError> {
     let conn = Connection::open_in_memory()?;
 
     // Change ID to use the ID from the smart contract once written
@@ -57,6 +81,25 @@ fn initialize_db() -> Result<Connection, rusqlite::Error> {
     Ok(conn)
 }
 
+fn insert_transaction(conn: &Connection, transaction: &Transactions) -> Result<(), DatabaseError> {
+    // Rust enums are checked at compile time, so we don't need to check that the transaction type is valid
+
+    // Error if data is null
+    // TODO: Error if data is not a valid signed Ethereum transaction
+    if transaction.data.is_none() {
+        return Err(DatabaseError::InvalidTransactionData(
+            "Transaction data cannot be null - all transactions must contain signed data".to_string()
+        ));
+    }
+
+    conn.execute(
+        "INSERT INTO transactions (transaction_type, data) VALUES (?1, ?2)",
+        (&transaction.transaction_type, &transaction.data),
+    )?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -65,4 +108,15 @@ mod tests {
     fn test_main() {
         assert!(main().is_ok());
     }
-}
+
+    #[test]
+    fn test_insert_transaction() {
+        let conn = initialize_db().unwrap();
+        let transaction = Transactions {
+            id: 0,
+            transaction_type: TransactionType::CreateToken,
+            data: Some("0x".as_bytes().to_vec()),
+        };
+        insert_transaction(&conn, &transaction).unwrap();
+    }
+}