Monero: support for legacy transactions (#308)

* add mlsag

* fix last commit

* fix miner v1 txs

* fix non-miner v1 txs

* add borromean + fix mlsag

* add block hash calculations

* fix for the jokester that added unreduced scalars

to the borromean signature of
2368d846e671bf79a1f84c6d3af9f0bfe296f043f50cf17ae5e485384a53707b

* Add Borromean range proof verifying functionality

* Add MLSAG verifying functionality

* fmt & clippy :)

* update MLSAG, ss2_elements will always be 2

* Add MgSig proving

* Tidy block.rs

* Tidy Borromean, fix bugs in last commit, replace todo! with unreachable!

* Mark legacy EcdhInfo amount decryption as experimental

* Correct comments

* Write a new impl of the merkle algorithm

This one tries to be understandable.

* Only pull in things only needed for experimental when experimental

* Stop caching the Monero block hash now in processor that we have Block::hash

* Corrections for recent processor commit

* Use a clearer algorithm for the merkle

Should also be more efficient due to not shifting as often.

* Tidy Mlsag

* Remove verify_rct_* from Mlsag

Both methods were ports from Monero, overtly specific without clear
documentation. They need to be added back in, with documentation, or included
in a node which provides the necessary further context for them to be naturally
understandable.

* Move mlsag/mod.rs to mlsag.rs

This should only be a folder if it has multiple files.

* Replace EcdhInfo terminology

The ECDH encrypted the amount, yet this struct contained the encrypted amount,
not some ECDH.

Also corrects the types on the original EcdhInfo struct.

* Correct handling of commitment masks when scanning

* Route read_array through read_raw_vec

* Misc lint

* Make a proper RctType enum

No longer caches RctType in the RctSignatures as well.

* Replace Vec<Bulletproofs> with Bulletproofs

Monero uses aggregated range proofs, so there's only ever one Bulletproof. This
is enforced with a consensus rule as well, making this safe.

As for why Monero uses a vec, it's probably due to the lack of variadic typing
used. Its effectively an Option for them, yet we don't need an Option since we
do have variadic typing (enums).

* Add necessary checks to Eventuality re: supported protocols

* Fix for block 202612 and fix merkel root calculations

* MLSAG (de)serialisation fix

ss_2_elements will not always be 2 as rct type 1 transactions are not enforced to have one input

* Revert "MLSAG (de)serialisation fix"

This reverts commit 5e710e0c96.

here it checks number of MGs == number of inputs:
0a1eaf26f9/src/cryptonote_core/tx_verification_utils.cpp (L60-59)

and here it checks for RctTypeFull number of MGs == 1:
0a1eaf26f9/src/ringct/rctSigs.cpp (L1325)

so number of inputs == 1
so ss_2_elements == 2

* update `MlsagAggregate` comment

* cargo update

Resolves a yanked crate

* Move location of serai-client in Cargo.toml

---------

Co-authored-by: Luke Parker <lukeparker5132@gmail.com>

processor/src/coins/monero.rs

@@ -13,7 +13,7 @@ use frost::{curve::Ed25519, ThresholdKeys};
 use monero_serai::{
   Protocol,
   transaction::Transaction,
-  block::Block as MBlock,
+  block::Block,
   rpc::{RpcError, HttpRpc, Rpc},
   wallet::{
     ViewPair, Scanner,
@@ -134,20 +134,18 @@ pub struct SignableTransaction {
   actual: MSignableTransaction,
 }
 
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct Block([u8; 32], MBlock);
 impl BlockTrait<Monero> for Block {
   type Id = [u8; 32];
   fn id(&self) -> Self::Id {
-    self.0
+    self.hash()
   }
 
   fn parent(&self) -> Self::Id {
-    self.1.header.previous
+    self.header.previous
   }
 
   fn time(&self) -> u64 {
-    self.1.header.timestamp
+    self.header.timestamp
   }
 
   fn median_fee(&self) -> Fee {
@@ -256,18 +254,22 @@ impl Coin for Monero {
   }
 
   async fn get_block(&self, number: usize) -> Result<Self::Block, CoinError> {
-    let hash = self.rpc.get_block_hash(number).await.map_err(|_| CoinError::ConnectionError)?;
-    let block = self.rpc.get_block(hash).await.map_err(|_| CoinError::ConnectionError)?;
-    Ok(Block(hash, block))
+    Ok(
+      self
+        .rpc
+        .get_block(self.rpc.get_block_hash(number).await.map_err(|_| CoinError::ConnectionError)?)
+        .await
+        .map_err(|_| CoinError::ConnectionError)?,
+    )
   }
 
   async fn get_outputs(
     &self,
-    block: &Self::Block,
+    block: &Block,
     key: EdwardsPoint,
   ) -> Result<Vec<Self::Output>, CoinError> {
     let mut txs = Self::scanner(key)
-      .scan(&self.rpc, &block.1)
+      .scan(&self.rpc, block)
       .await
       .map_err(|_| CoinError::ConnectionError)?
       .iter()
@@ -305,10 +307,8 @@ impl Coin for Monero {
   async fn get_eventuality_completions(
     &self,
     eventualities: &mut EventualitiesTracker<Eventuality>,
-    block: &Self::Block,
+    block: &Block,
   ) -> HashMap<[u8; 32], [u8; 32]> {
-    let block = &block.1;
-
     let mut res = HashMap::new();
     if eventualities.map.is_empty() {
       return res;
@@ -317,7 +317,7 @@ impl Coin for Monero {
     async fn check_block(
       coin: &Monero,
       eventualities: &mut EventualitiesTracker<Eventuality>,
-      block: &MBlock,
+      block: &Block,
       res: &mut HashMap<[u8; 32], [u8; 32]>,
     ) {
       for hash in &block.txs {
@@ -357,7 +357,7 @@ impl Coin for Monero {
         block.unwrap()
       };
 
-      check_block(self, eventualities, &block.1, &mut res).await;
+      check_block(self, eventualities, &block, &mut res).await;
     }
 
     // Also check the current block