MantaPay v1

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 ### Added
+- [\#286](https://github.com/Manta-Network/manta-rs/pull/286) MantaPay v1.0.0
 
 ### Changed
 - [\#283](https://github.com/Manta-Network/manta-rs/pull/283) Upgrade asset system.

manta-accounting/src/asset.rs

@@ -879,9 +879,8 @@ impl<K, I, V> AssetMap<I, V> for BTreeAssetMap<K, I, V>
 where
     K: Clone + Ord,
     I: Clone + Ord,
-    V: AddAssign + Clone + Default + Ord + Sub<Output = V>,
+    V: AddAssign + Clone + Default + Ord + Sub<Output = V> + for<'v> AddAssign<&'v V>,
     for<'v> &'v V: Sub<Output = V>,
-    for<'v> &'v V: AddAssign<&'v V>,
 {
     impl_asset_map_for_maps_body! { K, I, V, BTreeMapEntry }
 }
@@ -897,9 +896,8 @@ impl<K, I, V, S> AssetMap<I, V> for HashAssetMap<K, I, V, S>
 where
     K: Clone + Hash + Eq,
     I: Clone + Ord,
-    V: AddAssign + Clone + Default + Ord + Sub<Output = V>,
+    V: AddAssign + Clone + Default + Ord + Sub<Output = V> + for<'v> AddAssign<&'v V>,
     for<'v> &'v V: Sub<Output = V>,
-    for<'v> &'v V: AddAssign<&'v V>,
     S: BuildHasher + Default,
 {
     impl_asset_map_for_maps_body! { K, I, V, HashMapEntry }

manta-accounting/src/key.rs

@@ -327,7 +327,7 @@ where
     M: AccountMap<Account = AccountIndex>,
 {
     /// Account Collection
-    keys: H,
+    pub keys: H, // This has been made public because of compatibility issues with sdk.
 
     /// Account Map
     accounts: M,

manta-accounting/src/transfer/batch.rs

@@ -18,15 +18,43 @@
 
 // TODO: Move more of the batching algorithm here to improve library interfaces.
 
-use crate::transfer::{Asset, Configuration, Parameters, PreSender, Receiver, SpendingKey, Utxo};
+use crate::transfer::{
+    internal_pair, internal_zero_pair, Address, Asset, AuthorizationContext, Configuration,
+    Parameters, PreSender, Receiver, UtxoAccumulatorItem, UtxoAccumulatorModel,
+};
 use alloc::vec::Vec;
+use core::{fmt::Debug, hash::Hash};
 use manta_crypto::{
     accumulator::Accumulator,
-    rand::{CryptoRng, Rand, RngCore},
+    rand::{CryptoRng, RngCore},
 };
 use manta_util::into_array_unchecked;
 
+#[cfg(feature = "serde")]
+use manta_util::serde::{Deserialize, Serialize};
+
 /// Batch Join Structure
+#[cfg_attr(
+    feature = "serde",
+    derive(Deserialize, Serialize),
+    serde(
+        bound(
+            deserialize = "PreSender<C>: Deserialize<'de>",
+            serialize = "PreSender<C>: Serialize",
+        ),
+        crate = "manta_util::serde",
+        deny_unknown_fields
+    )
+)]
+#[derive(derivative::Derivative)]
+#[derivative(
+    Clone(bound = "PreSender<C>: Clone"),
+    Debug(bound = "PreSender<C>: Debug"),
+    Default(bound = "PreSender<C>: Default"),
+    Eq(bound = "PreSender<C>: Eq"),
+    Hash(bound = "PreSender<C>: Hash"),
+    PartialEq(bound = "PreSender<C>: PartialEq")
+)]
 pub struct Join<C>
 where
     C: Configuration,
@@ -42,25 +70,39 @@ impl<C> Join<C>
 where
     C: Configuration,
 {
-    /// Builds a new [`Join`] for `asset` using `spending_key` and `zero_key`.
+    /// Builds a new [`Join`] for `asset` using `address`.
     #[inline]
     pub fn new<R, const RECEIVERS: usize>(
         parameters: &Parameters<C>,
+        authorization_context: &mut AuthorizationContext<C>,
+        address: Address<C>,
         asset: Asset<C>,
-        spending_key: &SpendingKey<C>,
         rng: &mut R,
     ) -> ([Receiver<C>; RECEIVERS], Self)
     where
         R: CryptoRng + RngCore + ?Sized,
     {
         let mut receivers = Vec::with_capacity(RECEIVERS);
         let mut zeroes = Vec::with_capacity(RECEIVERS - 1);
-        let (receiver, pre_sender) =
-            spending_key.internal_pair(parameters, rng.gen(), asset.clone());
+        let asset_id = asset.id.clone();
+        let (receiver, pre_sender) = internal_pair::<C, _>(
+            parameters,
+            authorization_context,
+            address.clone(),
+            asset,
+            Default::default(),
+            rng,
+        );
         receivers.push(receiver);
         for _ in 1..RECEIVERS {
-            let (receiver, pre_sender) =
-                spending_key.internal_zero_pair(parameters, rng.gen(), asset.id.clone());
+            let (receiver, pre_sender) = internal_zero_pair::<C, _>(
+                parameters,
+                authorization_context,
+                address.clone(),
+                asset_id.clone(),
+                Default::default(),
+                rng,
+            );
             receivers.push(receiver);
             zeroes.push(pre_sender);
         }
@@ -69,13 +111,13 @@ where
 
     /// Inserts UTXOs for each sender in `self` into the `utxo_accumulator` for future proof selection.
     #[inline]
-    pub fn insert_utxos<A>(&self, utxo_accumulator: &mut A)
+    pub fn insert_utxos<A>(&self, parameters: &Parameters<C>, utxo_accumulator: &mut A)
     where
-        A: Accumulator<Item = Utxo<C>, Model = C::UtxoAccumulatorModel>,
+        A: Accumulator<Item = UtxoAccumulatorItem<C>, Model = UtxoAccumulatorModel<C>>,
     {
-        self.pre_sender.insert_utxo(utxo_accumulator);
+        self.pre_sender.insert_utxo(parameters, utxo_accumulator);
         for zero in &self.zeroes {
-            zero.insert_utxo(utxo_accumulator);
+            zero.insert_utxo(parameters, utxo_accumulator);
         }
     }
 }