Fix certificate update issue which cause subsequence object transfer …

…fail (#170)

* combine received cert and sent cert

* fix bugs preventing transfer of object after the first transaction, cause by incorrect certificate update.

added extensive test to check the certificate update logic.

* fix clippy

* use proper error propagation instead of unwrap

* use iterator in certificates function instead of Vec

some code clean up

* address PR comment: changed certificates in UserAccount to BTreeMap<TransactionDigest, CertifiedOrder>

* address PR comment : replaced incorrect unwrap with ?

fastpay/src/client.rs

@@ -80,8 +80,7 @@ fn make_client_state(
         account.key.copy(),
         committee,
         authority_clients,
-        account.sent_certificates.clone(),
-        account.received_certificates.clone(),
+        account.certificates.clone(),
         account.object_ids.clone(),
     )
 }

fastpay/src/config.rs

@@ -102,8 +102,7 @@ pub struct UserAccount {
     pub key: KeyPair,
     pub object_ids: BTreeMap<ObjectID, SequenceNumber>,
     pub gas_object_ids: BTreeSet<ObjectID>, // Every id in gas_object_ids should also be in object_ids.
-    pub sent_certificates: Vec<CertifiedOrder>,
-    pub received_certificates: Vec<CertifiedOrder>,
+    pub certificates: BTreeMap<TransactionDigest, CertifiedOrder>,
 }
 
 impl UserAccount {
@@ -119,8 +118,7 @@ impl UserAccount {
             key,
             object_ids,
             gas_object_ids,
-            sent_certificates: Vec::new(),
-            received_certificates: Vec::new(),
+            certificates: BTreeMap::new(),
         }
     }
 }
@@ -225,23 +223,18 @@ impl AccountsConfig {
             .get_mut(&state.address())
             .expect("Updated account should already exist");
         account.object_ids = state.object_ids().clone();
-        account.sent_certificates = state.sent_certificates().clone();
-        account.received_certificates = state.received_certificates().cloned().collect();
+        account.certificates = state.all_certificates().clone();
     }
 
     pub fn update_for_received_transfer(&mut self, certificate: CertifiedOrder) {
         match &certificate.order.kind {
             OrderKind::Transfer(transfer) => {
                 if let Address::FastPay(recipient) = &transfer.recipient {
                     if let Some(config) = self.accounts.get_mut(recipient) {
-                        if let Err(position) = config
-                            .received_certificates
-                            .binary_search_by_key(&certificate.order.digest(), |cert| {
-                                cert.order.digest()
-                            })
-                        {
-                            config.received_certificates.insert(position, certificate)
-                        }
+                        config
+                            .certificates
+                            .entry(certificate.order.digest())
+                            .or_insert(certificate);
                     }
                 }
             }

fastpay_core/src/authority.rs

@@ -292,31 +292,29 @@ impl AuthorityState {
         &self,
         request: ObjectInfoRequest,
     ) -> Result<ObjectInfoResponse, FastPayError> {
-        if let Some(seq) = request.request_sequence_number {
+        let requested_certificate = if let Some(seq) = request.request_sequence_number {
             // TODO(https://github.com/MystenLabs/fastnft/issues/123): Here we need to develop a strategy
             // to provide back to the client the object digest for specific objects requested. Probably,
             // we have to return the full ObjectRef and why not the actual full object here.
-            let obj = self
-                .object_state(&request.object_id)
-                .await
-                .map_err(|_| FastPayError::ObjectNotFound)?;
 
             // Get the Transaction Digest that created the object
-            let transaction_digest = self
-                .parent(&(request.object_id, seq.increment()?, obj.digest()))
-                .await
+            let parent_iterator = self
+                .get_parent_iterator(request.object_id, Some(seq.increment()?))
+                .await?;
+            let (_, transaction_digest) = parent_iterator
+                .first()
                 .ok_or(FastPayError::CertificateNotfound)?;
             // Get the cert from the transaction digest
-            let requested_certificate = Some(
-                self.read_certificate(&transaction_digest)
+            Some(
+                self.read_certificate(transaction_digest)
                     .await?
                     .ok_or(FastPayError::CertificateNotfound)?,
-            );
-            self.make_object_info(request.object_id, requested_certificate)
-                .await
+            )
         } else {
-            self.make_object_info(request.object_id, None).await
-        }
+            None
+        };
+        self.make_object_info(request.object_id, requested_certificate)
+            .await
     }
 }