refactor: cleanup

parse/Cargo.toml

@@ -9,12 +9,13 @@ edition = "2021"
 thiserror = "1"
 base64 = "0.21"
 solana-transaction-status = "1.16"
+solana-sdk = "1.16"
 tracing = "0.1"
+hex = "0.4"
 
 common = { path = "../common", package = "neon-proxy-common" }
 
 [dev-dependencies]
 solana-rpc-client = "1.16"
-solana-sdk = "1.16"
 test-log = { version = "0.2", default-features = false, features = ["trace"] }
 serde_json = "1"

parse/src/lib.rs

@@ -1,64 +1,65 @@
-use common::types::{NeonIxReceipt, NeonTxInfo};
+use common::types::NeonTxInfo;
 use solana_sdk::signature::Signature;
 use solana_transaction_status::option_serializer::OptionSerializer;
 use solana_transaction_status::EncodedConfirmedTransactionWithStatusMeta;
 use thiserror::Error;
 
 mod log;
+mod transaction;
 
 #[derive(Debug, Error)]
-pub enum InstructionParseError {}
-
-#[derive(Debug, Error)]
-pub enum TransactionParseError {
+pub enum Error {
+    #[error("Failed to decode solana")]
+    Solana,
+    #[error("Failed to decode logs")]
+    Log(#[from] log::Error),
     #[error("Failed to decode transaction")]
-    InvalidTransaction,
-    #[error("Failed to decode instruction")]
-    InstructionParseError(#[from] InstructionParseError),
-}
-
-fn parse_instruction(_data: &[u8]) -> Result<NeonIxReceipt, InstructionParseError> {
-    todo!()
+    Transaction(#[from] transaction::Error),
 }
 
+#[allow(dead_code)] // TODO
 #[derive(Debug)]
 struct SolTxSigSlotInfo {
     pub signature: Signature,
     pub block_slot: u64,
 }
 
+#[allow(dead_code)] // TODO
 #[derive(Debug)]
 struct SolTxMetaInfo {
     pub ident: SolTxSigSlotInfo,
 }
 
-// TODO: return NeonTxInfo
 pub fn parse(
     transaction: EncodedConfirmedTransactionWithStatusMeta,
-) -> Result<(), TransactionParseError> {
+) -> Result<Vec<NeonTxInfo>, Error> {
     let EncodedConfirmedTransactionWithStatusMeta {
         slot, transaction, ..
     } = transaction;
-    let tx = transaction
-        .transaction
-        .decode()
-        .ok_or(TransactionParseError::InvalidTransaction)?;
+    let tx = transaction.transaction.decode().ok_or(Error::Solana)?;
     let sig_slot_info = SolTxSigSlotInfo {
         signature: tx.signatures[0],
         block_slot: slot,
     };
-    let meta_info = SolTxMetaInfo {
+    let _meta_info = SolTxMetaInfo {
         ident: sig_slot_info,
     };
     for ix in tx.message.instructions() {
-        //let ix = parse_instruction(&ix.data)?;
+        let neon_tx = transaction::parse(&ix.data)?;
+        tracing::info!("neon tx {:?}", neon_tx);
     }
-    if let Some(OptionSerializer::Some(msgs)) = transaction.meta.map(|meta| meta.log_messages) {
-        if let Err(err) = log::parse(msgs) {
-            println!("log parsing error {:?}", err);
+    let _log_info = if let Some(OptionSerializer::Some(msgs)) =
+        transaction.meta.map(|meta| meta.log_messages)
+    {
+        match log::parse(msgs) {
+            Ok(log) => log,
+            Err(err) => panic!("log parsing error {:?}", err),
         }
-    }
-    Ok(())
+    } else {
+        todo!("no logs?")
+    };
+    tracing::info!("log info {:?}", _log_info);
+    Ok(Vec::new())
 }
 
 #[cfg(test)]

parse/src/transaction.rs

@@ -0,0 +1,37 @@
+use common::evm_loader::error::Error as NeonError;
+use common::evm_loader::types::Transaction;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("neon error")]
+    Neon(#[from] NeonError),
+    #[error("invalid instruction")]
+    InvalidInstruction,
+    #[error("not implemented")]
+    NotImplemented,
+}
+
+pub fn parse(bytes: &[u8]) -> Result<Option<Transaction>, Error> {
+    let tag = bytes.first().ok_or_else(|| Error::InvalidInstruction)?;
+    match tag {
+        0x31 => {
+            tracing::info!("found deposit instruction");
+        }
+        0x32 => {
+            tracing::info!("found execute from instruction");
+            let tx = decode_execute_from_ix(&bytes[1..])?;
+            return Ok(Some(tx));
+        }
+        _ => {
+            tracing::warn!("not implemented tag: {}", tag);
+        }
+    }
+    Ok(None) // TODO
+}
+
+fn decode_execute_from_ix(bytes: &[u8]) -> Result<Transaction, Error> {
+    let _treasure_index = u32::from_le_bytes(bytes[0..4].try_into().unwrap());
+    let tx = Transaction::from_rlp(&bytes[4..])?;
+    Ok(tx)
+}