Merge branch 'bat/remove-unused-assoc-ty' into bat/feature/refactor-cli

Author: batconjurer

apps/src/lib/client/rpc.rs

@@ -111,7 +111,7 @@ pub async fn query_results<C: namada::ledger::queries::Client + Sync>(
 /// Query the specified accepted transfers from the ledger
 pub async fn query_transfers<
     C: namada::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     client: &C,
     wallet: &mut Wallet<CliWalletUtils>,
@@ -263,7 +263,7 @@ pub async fn query_raw_bytes<C: namada::ledger::queries::Client + Sync>(
 /// Query token balance(s)
 pub async fn query_balance<
     C: namada::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     client: &C,
     wallet: &mut Wallet<CliWalletUtils>,
@@ -397,7 +397,7 @@ pub async fn query_transparent_balance<
 /// Query the token pinned balance(s)
 pub async fn query_pinned_balance<
     C: namada::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     client: &C,
     wallet: &mut Wallet<CliWalletUtils>,
@@ -761,7 +761,7 @@ pub async fn query_proposal<C: namada::ledger::queries::Client + Sync>(
 /// Query token shielded balance(s)
 pub async fn query_shielded_balance<
     C: namada::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     client: &C,
     wallet: &mut Wallet<CliWalletUtils>,

apps/src/lib/client/tx.rs

@@ -463,8 +463,6 @@ impl Default for CLIShieldedUtils {
 
 #[async_trait(?Send)]
 impl masp::ShieldedUtils for CLIShieldedUtils {
-    type C = crate::facade::tendermint_rpc::HttpClient;
-
     fn local_tx_prover(&self) -> LocalTxProver {
         if let Ok(params_dir) = env::var(masp::ENV_VAR_MASP_PARAMS_DIR) {
             let params_dir = PathBuf::from(params_dir);

shared/src/ledger/masp.rs

@@ -345,9 +345,6 @@ impl<P1, R1, N1>
 pub trait ShieldedUtils:
     Sized + BorshDeserialize + BorshSerialize + Default + Clone
 {
-    /// The type of the Tendermint client to make queries with
-    type C: crate::ledger::queries::Client + std::marker::Sync;
-
     /// Get a MASP transaction prover
     fn local_tx_prover(&self) -> LocalTxProver;
 
@@ -631,9 +628,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
 
     /// Fetch the current state of the multi-asset shielded pool into a
     /// ShieldedContext
-    pub async fn fetch(
+    pub async fn fetch<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         sks: &[ExtendedSpendingKey],
         fvks: &[ViewingKey],
     ) {
@@ -699,8 +696,8 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// transactions as a vector. More concretely, the HEAD_TX_KEY location
     /// stores the index of the last accepted transaction and each transaction
     /// is stored at a key derived from its index.
-    pub async fn fetch_shielded_transfers(
-        client: &U::C,
+    pub async fn fetch_shielded_transfers<C: Client + Sync>(
+        client: &C,
         last_txidx: u64,
     ) -> BTreeMap<(BlockHeight, TxIndex), (Epoch, Transfer, Transaction)> {
         // The address of the MASP account
@@ -710,7 +707,7 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
             .push(&HEAD_TX_KEY.to_owned())
             .expect("Cannot obtain a storage key");
         // Query for the index of the last accepted transaction
-        let head_txidx = query_storage_value::<U::C, u64>(client, &head_tx_key)
+        let head_txidx = query_storage_value::<C, u64>(client, &head_tx_key)
             .await
             .unwrap_or(0);
         let mut shielded_txs = BTreeMap::new();
@@ -723,7 +720,7 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
             // Obtain the current transaction
             let (tx_epoch, tx_height, tx_index, current_tx, current_stx) =
                 query_storage_value::<
-                    U::C,
+                    C,
                     (Epoch, BlockHeight, TxIndex, Transfer, Transaction),
                 >(client, &current_tx_key)
                 .await
@@ -744,10 +741,10 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// associated to notes, memos, and diversifiers. And the set of notes that
     /// we have spent are updated. The witness map is maintained to make it
     /// easier to construct note merkle paths in other code. See
-    /// <https://zips.z.cash/protocol/protocol.pdf#scan>.
-    pub async fn scan_tx(
+    /// <https://zips.z.cash/protocol/protocol.pdf#scan>
+    pub async fn scan_tx<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         height: BlockHeight,
         index: TxIndex,
         epoch: Epoch,
@@ -883,9 +880,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// Compute the total unspent notes associated with the viewing key in the
     /// context. If the key is not in the context, then we do not know the
     /// balance and hence we return None.
-    pub async fn compute_shielded_balance(
+    pub async fn compute_shielded_balance<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         vk: &ViewingKey,
     ) -> Option<MaspAmount> {
         // Cannot query the balance of a key that's not in the map
@@ -913,9 +910,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
 
     /// Query the ledger for the decoding of the given asset type and cache it
     /// if it is found.
-    pub async fn decode_asset_type(
+    pub async fn decode_asset_type<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         asset_type: AssetType,
     ) -> Option<(Address, Option<Key>, MaspDenom, Epoch)> {
         // Try to find the decoding in the cache
@@ -938,9 +935,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
 
     /// Query the ledger for the conversion that is allowed for the given asset
     /// type and cache it.
-    async fn query_allowed_conversion<'a>(
+    async fn query_allowed_conversion<'a, C: Client + Sync>(
         &'a mut self,
-        client: &U::C,
+        client: &C,
         asset_type: AssetType,
         conversions: &'a mut Conversions,
     ) {
@@ -963,9 +960,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// context and express that value in terms of the currently timestamped
     /// asset types. If the key is not in the context, then we do not know the
     /// balance and hence we return None.
-    pub async fn compute_exchanged_balance(
+    pub async fn compute_exchanged_balance<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         vk: &ViewingKey,
         target_epoch: Epoch,
     ) -> Option<MaspAmount> {
@@ -993,9 +990,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// the trace amount that could not be converted is moved from input to
     /// output.
     #[allow(clippy::too_many_arguments)]
-    async fn apply_conversion(
+    async fn apply_conversion<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         conv: AllowedConversion,
         asset_type: (Epoch, TokenAddress, MaspDenom),
         value: i128,
@@ -1047,9 +1044,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// note of the conversions that were used. Note that this function does
     /// not assume that allowed conversions from the ledger are expressed in
     /// terms of the latest asset types.
-    pub async fn compute_exchanged_amount(
+    pub async fn compute_exchanged_amount<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         mut input: MaspAmount,
         target_epoch: Epoch,
         mut conversions: Conversions,
@@ -1156,9 +1153,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// of the specified asset type. Return the total value accumulated plus
     /// notes and the corresponding diversifiers/merkle paths that were used to
     /// achieve the total value.
-    pub async fn collect_unspent_notes(
+    pub async fn collect_unspent_notes<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         vk: &ViewingKey,
         target: Amount,
         target_epoch: Epoch,
@@ -1226,8 +1223,8 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// keys to try to decrypt the output notes. If no transaction is pinned at
     /// the given payment address fails with
     /// `PinnedBalanceError::NoTransactionPinned`.
-    pub async fn compute_pinned_balance(
-        client: &U::C,
+    pub async fn compute_pinned_balance<C: Client + Sync>(
+        client: &C,
         owner: PaymentAddress,
         viewing_key: &ViewingKey,
     ) -> Result<(Amount, Epoch), PinnedBalanceError> {
@@ -1249,7 +1246,7 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
             .push(&(PIN_KEY_PREFIX.to_owned() + &owner.hash()))
             .expect("Cannot obtain a storage key");
         // Obtain the transaction pointer at the key
-        let txidx = rpc::query_storage_value::<U::C, u64>(client, &pin_key)
+        let txidx = rpc::query_storage_value::<C, u64>(client, &pin_key)
             .await
             .ok_or(PinnedBalanceError::NoTransactionPinned)?;
         // Construct the key for where the pinned transaction is stored
@@ -1259,7 +1256,7 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
         // Obtain the pointed to transaction
         let (tx_epoch, _tx_height, _tx_index, _tx, shielded) =
             rpc::query_storage_value::<
-                U::C,
+                C,
                 (Epoch, BlockHeight, TxIndex, Transfer, Transaction),
             >(client, &tx_key)
             .await
@@ -1297,9 +1294,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// the epoch of the transaction or even before, so exchange all these
     /// amounts to the epoch of the transaction in order to get the value that
     /// would have been displayed in the epoch of the transaction.
-    pub async fn compute_exchanged_pinned_balance(
+    pub async fn compute_exchanged_pinned_balance<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         owner: PaymentAddress,
         viewing_key: &ViewingKey,
     ) -> Result<(MaspAmount, Epoch), PinnedBalanceError> {
@@ -1322,9 +1319,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// Convert an amount whose units are AssetTypes to one whose units are
     /// Addresses that they decode to. All asset types not corresponding to
     /// the given epoch are ignored.
-    pub async fn decode_amount(
+    pub async fn decode_amount<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         amt: Amount,
         target_epoch: Epoch,
     ) -> HashMap<TokenAddress, token::Change> {
@@ -1355,9 +1352,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
 
     /// Convert an amount whose units are AssetTypes to one whose units are
     /// Addresses that they decode to.
-    pub async fn decode_all_amounts(
+    pub async fn decode_all_amounts<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         amt: Amount,
     ) -> MaspAmount {
         let mut res: HashMap<(Epoch, TokenAddress), Change> =
@@ -1394,9 +1391,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// understood that transparent account changes are effected only by the
     /// amounts and signatures specified by the containing Transfer object.
     #[cfg(feature = "masp-tx-gen")]
-    pub async fn gen_shielded_transfer(
+    pub async fn gen_shielded_transfer<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         args: &args::TxTransfer,
         shielded_gas: bool,
     ) -> Result<
@@ -1611,9 +1608,9 @@ impl<U: ShieldedUtils> ShieldedContext<U> {
     /// transactions. If an owner is specified, then restrict the set to only
     /// transactions crediting/debiting the given owner. If token is specified,
     /// then restrict set to only transactions involving the given token.
-    pub async fn query_tx_deltas(
+    pub async fn query_tx_deltas<C: Client + Sync>(
         &mut self,
-        client: &U::C,
+        client: &C,
         query_owner: &Either<BalanceOwner, Vec<Address>>,
         query_token: &Option<Address>,
         viewing_keys: &HashMap<String, ExtendedViewingKey>,

shared/src/ledger/tx.rs

@@ -1241,7 +1241,7 @@ pub async fn build_ibc_transfer<
 /// Returns true only if a new decoding has been added to the given set.
 async fn add_asset_type<
     C: crate::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     asset_types: &mut HashSet<(Address, Option<Key>, MaspDenom, Epoch)>,
     shielded: &mut ShieldedContext<U>,
@@ -1262,7 +1262,7 @@ async fn add_asset_type<
 /// type information.
 async fn used_asset_types<
     C: crate::ledger::queries::Client + Sync,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
     P,
     R,
     K,
@@ -1314,7 +1314,7 @@ async fn used_asset_types<
 pub async fn build_transfer<
     C: crate::ledger::queries::Client + Sync,
     V: WalletUtils,
-    U: ShieldedUtils<C = C>,
+    U: ShieldedUtils,
 >(
     client: &C,
     wallet: &mut Wallet<V>,