store pending withdrawals always before delivery (#74)

* store pending withdrawals always before delivery

* store receipts before auto accumulating

* rework log messages

* cargo fmt

---------

Co-authored-by: David Salami <wizdave97@gmail.com>

Author: seunlanlege

Cargo.lock

@@ -267,17 +267,20 @@ where
 				// We should not store messages when they are delivered to hyperbridge
 				if chain_a.state_machine_id().state_id != coprocessor.state_machine() {
 					if !receipts.is_empty() {
+						// Store receipts in database before auto accumulation
+						tracing::trace!(target: "tesseract", "Persisting {} deliveries from {}->{} to the db", receipts.len(), chain_b.name(), chain_a.name());
+						if let Err(err) = tx_payment.store_messages(receipts.clone()).await {
+							tracing::error!(
+								"Failed to persist {} deliveries to database: {err:?}",
+								receipts.len()
+							)
+						}
 						// Send receipts to the fee accumulation task
 						match fee_acc_sender.send(receipts).await {
-							Err(sent) => {
-								// If for aome reason the receiver has been dropped, store receipts
-								// in db so they can be accumulated manually
-								tracing::info!(target: "tesseract", "Storing {} deliveries from {} to {} inside the database", sent.0.len(), chain_b.name(), chain_a.name());
-								if let Err(err) = tx_payment.store_messages(sent.0).await {
-									tracing::error!(
-										"Failed to store some delivered messages to database: {err:?}"
-									)
-								}
+							Err(_sent) => {
+								tracing::error!(
+									"Fee auto accumulation failed You can try again manually"
+								)
 							},
 							_ => {},
 						}
@@ -378,23 +381,21 @@ async fn fee_accumulation<
 							.await?;
 
 							observe_challenge_period(&dest, &hyperbridge, dest_height).await?;
+							let mut commitments =  vec![];
 							for proof in proofs {
+								commitments.extend_from_slice(&proof.commitments);
 								hyperbridge.accumulate_fees(proof).await?;
 							}
 							tracing::info!("Fee accumulation was sucessful");
-
+							// If delete fails, not an issue, they'll be deleted whenever manual accumulation is triggered
+							let _ = tx_payment.delete_claimed_entries(commitments).await;
 							Ok::<_, anyhow::Error>(())
 						};
 
 						match lambda().await {
 							Ok(()) => {},
 							Err(err) => {
 								tracing::error!("Error accummulating some fees, receipts have been stored in the db, you can try again manually \n{err:?}");
-								if let Err(err) = tx_payment.store_messages(receipts).await {
-									tracing::error!(
-										"Failed to store some delivered messages to database: {err:?}"
-									)
-								}
 							}
 						}
 					}

messaging/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "tesseract"
-version = "0.2.8"
+version = "0.2.9"
 edition = "2021"
 description = "Chain agnostic relayer implementation for ISMP"
 authors = ["Polytope Labs <hello@polytope.technology>"]

relayer/Cargo.toml

@@ -288,7 +288,8 @@ where
 	let frequency = Duration::from_secs(config.withdrawal_frequency.unwrap_or(86_400));
 	tracing::info!("Auto-withdraw frequency set to {:?}", frequency);
 	// default to $100
-	let min_amount: U256 = (config.minimum_withdrawal_amount.unwrap_or(100) * 10u64.pow(18)).into();
+	let min_amount: U256 =
+		(config.minimum_withdrawal_amount.unwrap_or(100) as u128 * 10u128.pow(18)).into();
 
 	tracing::info!("Minimum auto-withdrawal amount set to ${:?}", Cost(min_amount));
 	let mut interval = interval(frequency);
@@ -326,13 +327,18 @@ where
 							.await?;
 						tracing::info!("Request submitted to hyperbridge successfully");
 						tracing::info!("Starting delivery of withdrawal message to {:?}", chain);
+
+						// persist the withdrawal in-case delivery fails, so it's not lost forever
+						let ids = moved_db.store_pending_withdrawals(vec![result.clone()]).await?;
+
 						match deliver_post_request(&client, &hyperbridge, result.clone()).await {
-							Ok(_) => {},
+							Ok(_) => {
+								if let Err(e) = moved_db.delete_pending_withdrawals(ids).await {
+									tracing::error!("Error encountered while deleting pending withdrawals from the db: {e:?}, \n NOTE: The withdrawal request was successfully delivered.");
+								}
+							},
 							Err(err) => {
-								// persist the withdrawal in-case delivery fails, so it's not lost forever
-								tracing::error!("Encountered an error while delivering withdrawal request: {err:?}");
-								moved_db.store_pending_withdrawals(vec![result]).await?;
-								tracing::info!("Stored the failed withdrawal request in the db, so they can be retried later.");
+								tracing::info!("Failed to deliver withdrawal request: {err:?}, they will be retried.");
 							}
 						};
 						Ok(())