DO NOT MERGE: SBT signer sync

CHANGELOG.md

@@ -5,6 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased]
 ### Added
+- [\#335](https://github.com/Manta-Network/manta-rs/pull/335) SBT synchronization method for the signer. 
 - [\#330](https://github.com/Manta-Network/manta-rs/pull/330) Merkle tree batch insertions.
 
 ### Changed

manta-accounting/src/wallet/mod.rs

@@ -272,6 +272,36 @@ where
         Ok(())
     }
 
+    /// Pulls data from the ledger, synchronizing the wallet and balance state. This method loops
+    /// continuously calling [`sbt_sync_partial`](Self::sbt_sync_partial) until all the ledger data has
+    /// arrived at and has been synchronized with the wallet.
+    ///
+    /// # Failure Conditions
+    ///
+    /// This method returns an element of type [`Error`] on failure, which can result from any
+    /// number of synchronization issues between the wallet, the ledger, and the signer. See the
+    /// [`InconsistencyError`] type for more information on the kinds of errors that can occur and
+    /// how to resolve them.
+    ///
+    /// # Note
+    ///
+    /// In general, this method does not update the [`Utxo`] accumulator, thus making the new assets
+    /// effectively non-spendable. Therefore, this method should only be used when the pallet does not
+    /// allow [`PrivateTransfer`]s or [`ToPublic`] transactions, for example in the case of
+    /// Soul-Bound Tokens (SBTs).
+    ///
+    /// [`Utxo`]: Configuration::Utxo
+    /// [`PrivateTransfer`]: crate::transfer::canonical::PrivateTransfer
+    /// [`ToPublic`]: crate::transfer::canonical::ToPublic
+    #[inline]
+    pub async fn sbt_sync(&mut self) -> Result<(), Error<C, L, S>>
+    where
+        L: ledger::Read<SyncData<C>, Checkpoint = S::Checkpoint>,
+    {
+        while self.sbt_sync_partial().await?.is_continue() {}
+        Ok(())
+    }
+
     /// Pulls data from the ledger, synchronizing the wallet and balance state. This method
     /// builds a [`InitialSyncRequest`] by continuously calling [`read`](ledger::Read::read)
     /// until all the ledger data has arrived. Once the request is built, it executes
@@ -298,7 +328,7 @@ where
         S::Checkpoint: signer::Checkpoint<C>,
     {
         let mut is_continue = true;
-        let mut checkpoint = Default::default();
+        let mut checkpoint = S::Checkpoint::default();
         let mut request = InitialSyncRequest::<C>::default();
         let parameters = self
             .signer
@@ -309,15 +339,12 @@ where
             let ReadResponse {
                 should_continue,
                 data,
-            } = self
-                .ledger
-                .read(&checkpoint)
-                .await
-                .map_err(Error::LedgerConnectionError)?;
+            } = self.read_from_ledger().await?;
+            let more = InitialSyncRequest::from_initial_sync_data(&parameters, data);
             is_continue = should_continue;
-            request.extend_with_data(&parameters, data);
             checkpoint
-                .update_from_utxo_count(request.utxo_data.iter().map(|utxos| utxos.len()).collect())
+                .update_from_utxo_count(more.utxo_data.iter().map(|utxos| utxos.len()).collect());
+            request.extend(more);
         }
         self.signer_initial_sync(request).await?;
         Ok(())
@@ -341,6 +368,56 @@ where
         self.sync_with().await
     }
 
+    /// Reads data from the ledger.
+    #[inline]
+    async fn read_from_ledger<D>(&mut self) -> Result<ReadResponse<D>, Error<C, L, S>>
+    where
+        L: ledger::Read<D, Checkpoint = S::Checkpoint>,
+    {
+        self.ledger
+            .read(&self.checkpoint)
+            .await
+            .map_err(Error::LedgerConnectionError)
+    }
+
+    /// Pulls data from the ledger, synchronizing the wallet and balance state. This method returns
+    /// a [`ControlFlow`] for matching against to determine if the wallet requires more
+    /// synchronization.
+    ///
+    /// # Failure Conditions
+    ///
+    /// This method returns an element of type [`Error`] on failure, which can result from any
+    /// number of synchronization issues between the wallet, the ledger, and the signer. See the
+    /// [`InconsistencyError`] type for more information on the kinds of errors that can occur and
+    /// how to resolve them.
+    ///
+    /// # Note
+    ///
+    /// In general, this method does not update the [`Utxo`] accumulator, thus making the new assets
+    /// effectively non-spendable. Therefore, this method should only be used when the pallet does not
+    /// allow [`PrivateTransfer`]s or [`ToPublic`] transactions, for example in the case of
+    /// Soul-Bound Tokens (SBTs).
+    ///
+    /// [`Utxo`]: Configuration::Utxo
+    /// [`PrivateTransfer`]: crate::transfer::canonical::PrivateTransfer
+    /// [`ToPublic`]: crate::transfer::canonical::ToPublic
+    #[inline]
+    pub async fn sbt_sync_partial(&mut self) -> Result<ControlFlow, Error<C, L, S>>
+    where
+        L: ledger::Read<SyncData<C>, Checkpoint = S::Checkpoint>,
+    {
+        let ReadResponse {
+            should_continue,
+            data,
+        } = self.read_from_ledger().await?;
+        self.signer_sbt_sync(SyncRequest {
+            origin_checkpoint: self.checkpoint.clone(),
+            data,
+        })
+        .await?;
+        Ok(ControlFlow::should_continue(should_continue))
+    }
+
     /// Pulls data from the ledger, synchronizing the wallet and balance state.
     #[inline]
     async fn sync_with(&mut self) -> Result<ControlFlow, Error<C, L, S>>
@@ -350,11 +427,7 @@ where
         let ReadResponse {
             should_continue,
             data,
-        } = self
-            .ledger
-            .read(&self.checkpoint)
-            .await
-            .map_err(Error::LedgerConnectionError)?;
+        } = self.read_from_ledger().await?;
         self.signer_sync(SyncRequest {
             origin_checkpoint: self.checkpoint.clone(),
             data,
@@ -431,6 +504,20 @@ where
         self.process_sync_response(response)
     }
 
+    /// Performs an sbt synchronization with the signer against the given `request`.
+    #[inline]
+    async fn signer_sbt_sync(
+        &mut self,
+        request: SyncRequest<C, S::Checkpoint>,
+    ) -> Result<(), Error<C, L, S>> {
+        let response = self
+            .signer
+            .sbt_sync(request)
+            .await
+            .map_err(Error::SignerConnectionError)?;
+        self.process_sync_response(response)
+    }
+
     /// Checks if `transaction` can be executed on the balance state of `self`, returning the
     /// kind of update that should be performed on the balance state if the transaction is
     /// successfully posted to the ledger.

manta-accounting/src/wallet/signer/functions.rs

@@ -129,7 +129,6 @@ fn insert_next_item<C>(
     utxo_accumulator: &mut C::UtxoAccumulator,
     assets: &mut C::AssetMap,
     parameters: &Parameters<C>,
-    utxo: Utxo<C>,
     identified_asset: IdentifiedAsset<C>,
     nullifiers: &mut Vec<Nullifier<C>>,
     deposit: &mut Vec<Asset<C>>,
@@ -138,26 +137,24 @@ fn insert_next_item<C>(
     C: Configuration,
 {
     let IdentifiedAsset::<C> { identifier, asset } = identified_asset;
-    let (_, computed_utxo, nullifier) = parameters.derive_spend(
+    let (_, utxo, nullifier) = parameters.derive_spend(
         authorization_context,
         identifier.clone(),
         asset.clone(),
         rng,
     );
-    if computed_utxo.is_related(&utxo) {
-        if let Some(index) = nullifiers
-            .iter()
-            .position(move |n| n.is_related(&nullifier))
-        {
-            nullifiers.remove(index);
-        } else {
-            utxo_accumulator.insert(&item_hash::<C>(parameters, &utxo));
-            if !asset.is_zero() {
-                deposit.push(asset.clone());
-            }
-            assets.insert(identifier, asset);
-            return;
+    if let Some(index) = nullifiers
+        .iter()
+        .position(move |n| n.is_related(&nullifier))
+    {
+        nullifiers.remove(index);
+    } else {
+        utxo_accumulator.insert(&item_hash::<C>(parameters, &utxo));
+        if !asset.is_zero() {
+            deposit.push(asset.clone());
         }
+        assets.insert(identifier, asset);
+        return;
     }
     utxo_accumulator.insert_nonprovable(&item_hash::<C>(parameters, &utxo));
 }
@@ -231,7 +228,6 @@ where
                 utxo_accumulator,
                 assets,
                 parameters,
-                utxo,
                 transfer::utxo::IdentifiedAsset::new(identifier, asset),
                 &mut nullifiers,
                 &mut deposit,
@@ -275,6 +271,53 @@ where
     }
 }
 
+/// Updates the internal ledger state, returning the new asset distribution.
+#[allow(clippy::too_many_arguments)]
+#[inline]
+fn sbt_sync_with<C, I>(
+    authorization_context: &mut AuthorizationContext<C>,
+    assets: &mut C::AssetMap,
+    checkpoint: &mut C::Checkpoint,
+    parameters: &Parameters<C>,
+    inserts: I,
+    utxo_count: Vec<usize>,
+    nullifier_count: usize,
+    is_partial: bool,
+) -> SyncResponse<C, C::Checkpoint>
+where
+    C: Configuration,
+    I: Iterator<Item = (Utxo<C>, Note<C>)>,
+{
+    let mut deposit = Vec::new();
+    let decryption_key = parameters.derive_decryption_key(authorization_context);
+    for (utxo, note) in inserts {
+        if let Some((identifier, asset)) = parameters.open_with_check(&decryption_key, &utxo, note)
+        {
+            if !asset.is_zero() {
+                deposit.push(asset.clone());
+            }
+            assets.insert(identifier, asset);
+        }
+    }
+    checkpoint.update_from_nullifiers(nullifier_count);
+    checkpoint.update_from_utxo_count(utxo_count);
+    SyncResponse {
+        checkpoint: checkpoint.clone(),
+        balance_update: if is_partial {
+            // TODO: Whenever we are doing a full update, don't even build the `deposit` and
+            //       `withdraw` vectors, since we won't be needing them.
+            BalanceUpdate::Partial {
+                deposit,
+                withdraw: Default::default(),
+            }
+        } else {
+            BalanceUpdate::Full {
+                assets: assets.assets().into(),
+            }
+        },
+    }
+}
+
 /// Builds the [`PreSender`] associated to `identifier` and `asset`.
 #[inline]
 fn build_pre_sender<C>(
@@ -619,17 +662,14 @@ where
     account.address(&parameters.parameters)
 }
 
-/// Updates `assets`, `checkpoint` and `utxo_accumulator`, returning the new asset distribution.
+/// Checks that the origin checkpoint in `request` is less or equal than `checkpoint`.
+/// If it is strictly less, it prunes the data in `request` accordingly.
 #[inline]
-pub fn sync<C>(
+fn prune_sync_request<C>(
     parameters: &SignerParameters<C>,
-    authorization_context: &mut AuthorizationContext<C>,
-    assets: &mut C::AssetMap,
-    checkpoint: &mut C::Checkpoint,
-    utxo_accumulator: &mut C::UtxoAccumulator,
+    checkpoint: &C::Checkpoint,
     mut request: SyncRequest<C, C::Checkpoint>,
-    rng: &mut C::Rng,
-) -> Result<SyncResponse<C, C::Checkpoint>, SyncError<C::Checkpoint>>
+) -> Result<(bool, SyncData<C>), SyncError<C::Checkpoint>>
 where
     C: Configuration,
 {
@@ -647,24 +687,76 @@ where
             parameters.parameters.utxo_accumulator_item_hash(),
             checkpoint,
         );
-        let SyncData {
+        Ok((has_pruned, request.data))
+    }
+}
+
+/// Updates `assets` and `checkpoint`, returning the new asset distribution.
+#[inline]
+pub fn sbt_sync<C>(
+    parameters: &SignerParameters<C>,
+    authorization_context: &mut AuthorizationContext<C>,
+    assets: &mut C::AssetMap,
+    checkpoint: &mut C::Checkpoint,
+    request: SyncRequest<C, C::Checkpoint>,
+) -> Result<SyncResponse<C, C::Checkpoint>, SyncError<C::Checkpoint>>
+where
+    C: Configuration,
+{
+    let utxo_count = request.utxo_count(&parameters.parameters);
+    let (
+        has_pruned,
+        SyncData {
             utxo_note_data,
             nullifier_data,
-        } = request.data;
-        let response = sync_with::<C, _>(
-            authorization_context,
-            assets,
-            checkpoint,
-            utxo_accumulator,
-            &parameters.parameters,
-            utxo_note_data.into_iter(),
+        },
+    ) = prune_sync_request(parameters, checkpoint, request)?;
+    Ok(sbt_sync_with(
+        authorization_context,
+        assets,
+        checkpoint,
+        &parameters.parameters,
+        utxo_note_data.into_iter(),
+        utxo_count,
+        nullifier_data.len(),
+        !has_pruned,
+    ))
+}
+
+/// Updates `assets`, `checkpoint` and `utxo_accumulator`, returning the new asset distribution.
+#[inline]
+pub fn sync<C>(
+    parameters: &SignerParameters<C>,
+    authorization_context: &mut AuthorizationContext<C>,
+    assets: &mut C::AssetMap,
+    checkpoint: &mut C::Checkpoint,
+    utxo_accumulator: &mut C::UtxoAccumulator,
+    request: SyncRequest<C, C::Checkpoint>,
+    rng: &mut C::Rng,
+) -> Result<SyncResponse<C, C::Checkpoint>, SyncError<C::Checkpoint>>
+where
+    C: Configuration,
+{
+    let (
+        has_pruned,
+        SyncData {
+            utxo_note_data,
             nullifier_data,
-            !has_pruned,
-            rng,
-        );
-        utxo_accumulator.commit();
-        Ok(response)
-    }
+        },
+    ) = prune_sync_request(parameters, checkpoint, request)?;
+    let response = sync_with::<C, _>(
+        authorization_context,
+        assets,
+        checkpoint,
+        utxo_accumulator,
+        &parameters.parameters,
+        utxo_note_data.into_iter(),
+        nullifier_data,
+        !has_pruned,
+        rng,
+    );
+    utxo_accumulator.commit();
+    Ok(response)
 }
 
 /// Signs a withdraw transaction for `asset` sent to `address`.