Remove monero-rs types

Still missing an updated RPC file. Restructures the library as it makes 
sense

coins/monero/src/rpc.rs

@@ -1,25 +1,16 @@
-use std::{fmt::Debug, str::FromStr};
+use std::fmt::Debug;
 
 use thiserror::Error;
 
-use hex::ToHex;
-
 use curve25519_dalek::edwards::{EdwardsPoint, CompressedEdwardsY};
 
-use monero::{
-  Hash,
-  blockdata::{
-    transaction::{TxIn, Transaction},
-    block::Block
-  },
-  consensus::encode::{serialize, deserialize}
-};
-
 use serde::{Serialize, Deserialize, de::DeserializeOwned};
 use serde_json::json;
 
 use reqwest;
 
+use crate::transaction::Transaction;
+
 #[derive(Deserialize, Debug)]
 pub struct EmptyResponse {}
 #[derive(Deserialize, Debug)]
@@ -106,7 +97,7 @@ impl Rpc {
     Ok(self.rpc_call::<Option<()>, HeightResponse>("get_height", None).await?.height)
   }
 
-  pub async fn get_transactions(&self, hashes: Vec<Hash>) -> Result<Vec<Transaction>, RpcError> {
+  pub async fn get_transactions(&self, hashes: Vec<[u8; 32]>) -> Result<Vec<Transaction>, RpcError> {
     #[derive(Deserialize, Debug)]
     struct TransactionResponse {
       as_hex: String,
@@ -118,35 +109,37 @@ impl Rpc {
     }
 
     let txs: TransactionsResponse = self.rpc_call("get_transactions", Some(json!({
-      "txs_hashes": hashes.iter().map(|hash| hash.encode_hex()).collect::<Vec<String>>()
+      "txs_hashes": hashes.iter().map(|hash| hex::encode(&hash)).collect::<Vec<String>>()
     }))).await?;
     if txs.txs.len() != hashes.len() {
       Err(RpcError::TransactionsNotFound(txs.txs.len(), hashes.len()))?;
     }
 
-    let mut res: Vec<Transaction> = Vec::with_capacity(txs.txs.len());
-    for tx in txs.txs {
-      res.push(
-        deserialize(
-          &rpc_hex(if tx.as_hex.len() != 0 { &tx.as_hex } else { &tx.pruned_as_hex })?
-        ).map_err(|_| RpcError::InvalidTransaction)?
-      );
-
-      if tx.as_hex.len() == 0 {
-        match res[res.len() - 1].prefix.inputs[0] {
-          TxIn::Gen { .. } => 0,
-          _ => Err(RpcError::TransactionsNotFound(hashes.len() - 1, hashes.len()))?
-        };
-      }
-    }
-
-    Ok(res)
+    /*
+    Ok(
+      txs.txs.iter().filter_map(
+        |tx| rpc_hex(if tx.as_hex.len() != 0 { &tx.as_hex } else { &tx.pruned_as_hex }).ok()
+          .and_then(|mut bytes| Transaction::deserialize(&mut bytes).ok())
+          // https://github.com/monero-project/monero/issues/8311
+          .filter(
+            if tx.as_hex.len() == 0 {
+              match res[res.len() - 1].prefix.inputs[0] {
+                Input::Gen { .. } => true,
+                _ => false
+              }
+            }
+          )
+      )
+    )
+    */
+    Ok(vec![])
   }
 
+  /*
   pub async fn get_block(&self, height: usize) -> Result<Block, RpcError> {
     #[derive(Deserialize, Debug)]
     struct BlockResponse {
-      blob: String
+      json: String
     }
 
     let block: JsonRpcResponse<BlockResponse> = self.rpc_call("json_rpc", Some(json!({
@@ -162,17 +155,21 @@ impl Rpc {
       ).expect("Monero returned a block we couldn't deserialize")
     )
   }
+  */
 
   pub async fn get_block_transactions(&self, height: usize) -> Result<Vec<Transaction>, RpcError> {
+    /*
     let block = self.get_block(height).await?;
     let mut res = vec![block.miner_tx];
     if block.tx_hashes.len() != 0 {
-      res.extend(self.get_transactions(block.tx_hashes).await?);
+      res.extend(self.get_transactions(block.tx_hashes.iter().map(|hash| hash.0).collect()).await?);
     }
     Ok(res)
+    */
+    Ok(vec![])
   }
 
-  pub async fn get_o_indexes(&self, hash: Hash) -> Result<Vec<u64>, RpcError> {
+  pub async fn get_o_indexes(&self, hash: [u8; 32]) -> Result<Vec<u64>, RpcError> {
     #[derive(Serialize, Debug)]
     struct Request {
       txid: [u8; 32]
@@ -190,8 +187,8 @@ impl Rpc {
 
     let indexes: OIndexes = self.bin_call("get_o_indexes.bin", monero_epee_bin_serde::to_bytes(
       &Request {
-        txid: hash.0
-      }).expect("Couldn't serialize a request")
+        txid: hash
+      }).unwrap()
     ).await?;
 
     Ok(indexes.o_indexes)
@@ -223,13 +220,16 @@ impl Rpc {
     }))).await?;
 
     let txs = self.get_transactions(
-      outs.outs.iter().map(|out| Hash::from_str(&out.txid).expect("Monero returned an invalid hash")).collect()
+      outs.outs.iter().map(|out|
+        rpc_hex(&out.txid).expect("Monero returned an invalidly encoded hash")
+          .try_into().expect("Monero returned an invalid sized hash")
+      ).collect()
     ).await?;
     // TODO: Support time based lock times. These shouldn't be needed, and it may be painful to
     // get the median time for the given height, yet we do need to in order to be complete
     outs.outs.iter().enumerate().map(
       |(i, out)| Ok(
-        if txs[i].prefix.unlock_time.0 <= u64::try_from(height).unwrap() {
+        if txs[i].prefix.unlock_time <= u64::try_from(height).unwrap() {
           Some([rpc_point(&out.key)?, rpc_point(&out.mask)?])
         } else { None }
       )
@@ -279,8 +279,10 @@ impl Rpc {
       reason: String
     }
 
+    let mut buf = Vec::with_capacity(2048);
+    tx.serialize(&mut buf).unwrap();
     let res: SendRawResponse = self.rpc_call("send_raw_transaction", Some(json!({
-      "tx_as_hex": hex::encode(&serialize(tx))
+      "tx_as_hex": hex::encode(&buf)
     }))).await?;
 
     if res.status != "OK" {