Release 10/10

consumer/src/events.rs

@@ -546,11 +546,7 @@ impl Processor {
                         self.process_nft(
                             EventKind::RetryMintToCollection,
                             &key,
-                            self.retry_mint_to_collection(
-                                &UncompressedRef(self.solana()),
-                                &key,
-                                payload,
-                            ),
+                            self.retry_mint_to_collection(&key, payload),
                         )
                         .await
                     },
@@ -625,11 +621,7 @@ impl Processor {
                         self.process_nft(
                             EventKind::RetryMintOpenDrop,
                             &key,
-                            self.retry_mint_to_collection(
-                                &UncompressedRef(self.solana()),
-                                &key,
-                                payload,
-                            ),
+                            self.retry_mint_to_collection(&key, payload),
                         )
                         .await
                     },
@@ -1185,11 +1177,8 @@ impl Processor {
         Ok(tx.into())
     }
 
-    async fn retry_mint_to_collection<
-        B: MintBackend<MintMetaplexMetadataTransaction, MintMetaplexAddresses>,
-    >(
+    async fn retry_mint_to_collection(
         &self,
-        backend: &B,
         key: &SolanaNftEventKey,
         payload: MintMetaplexMetadataTransaction,
     ) -> ProcessResult<SolanaPendingTransaction> {
@@ -1202,6 +1191,31 @@ impl Processor {
 
         let collection = collection.ok_or(ProcessorErrorKind::RecordNotFound)?;
 
+        if payload.compressed {
+            let backend = &CompressedRef(self.solana());
+
+            let tx = backend
+                .mint(&collection, payload)
+                .map_err(ProcessorErrorKind::Solana)?;
+
+            let leaf_model = CompressionLeaf::find_by_id(conn, id)
+                .await?
+                .ok_or(ProcessorErrorKind::RecordNotFound)?;
+
+            let mut compression_leaf: compression_leafs::ActiveModel = leaf_model.into();
+
+            compression_leaf.merkle_tree = Set(tx.addresses.merkle_tree.to_string());
+            compression_leaf.tree_authority = Set(tx.addresses.tree_authority.to_string());
+            compression_leaf.tree_delegate = Set(tx.addresses.tree_delegate.to_string());
+            compression_leaf.leaf_owner = Set(tx.addresses.leaf_owner.to_string());
+
+            compression_leaf.update(conn).await?;
+
+            return Ok(tx.into());
+        }
+
+        let backend = &UncompressedRef(self.solana());
+
         let tx = backend
             .mint(&collection, payload)
             .map_err(ProcessorErrorKind::Solana)?;

consumer/src/solana.rs

@@ -25,7 +25,10 @@ use mpl_token_metadata::{
     },
     state::{Creator, DataV2, EDITION, PREFIX},
 };
-use solana_client::rpc_client::RpcClient as SolanaRpcClient;
+use solana_client::{
+    client_error::{ClientError, ClientErrorKind},
+    rpc_client::RpcClient as SolanaRpcClient,
+};
 use solana_program::{
     instruction::Instruction, program_pack::Pack, pubkey::Pubkey,
     system_instruction::create_account, system_program,
@@ -59,16 +62,18 @@ use crate::{
     },
 };
 
-macro_rules! call_with_retry {
+macro_rules! with_retry {
     ($expr:expr) => {{
         (|| $expr)
             .retry(
                 &ExponentialBuilder::default()
                     .with_jitter()
                     .with_min_delay(Duration::from_millis(30))
-                    .with_max_times(10),
+                    .with_max_times(15),
             )
-            .call()
+            .notify(|err: &ClientError, dur: Duration| {
+                error!("retrying error {:?} in {:?}", err, dur);
+            })
     }};
 }
 
@@ -201,9 +206,11 @@ impl Solana {
         &self,
         signature: &Signature,
     ) -> Result<u32, SolanaAssetIdError> {
-        let response = self
-            .rpc()
-            .get_transaction(signature, UiTransactionEncoding::Json)?;
+        let response = with_retry!(
+            self.rpc()
+                .get_transaction(signature, UiTransactionEncoding::Json)
+        )
+        .call()?;
 
         let meta = response
             .transaction
@@ -247,10 +254,7 @@ impl Solana {
         let signatures = transaction
             .signed_message_signatures
             .iter()
-            .map(|s| {
-                Signature::from_str(s)
-                    .map_err(|e| anyhow!(format!("failed to parse signature: {e}")))
-            })
+            .map(|s| Signature::from_str(s).context("failed to parse signature"))
             .collect::<Result<Vec<Signature>>>()?;
 
         let message = bincode::deserialize(
@@ -265,13 +269,21 @@ impl Solana {
             message,
         };
 
-        call_with_retry!(self.rpc().send_and_confirm_transaction(&transaction))
-            .map(|s| s.to_string())
+        let signature = with_retry!(self.rpc().send_and_confirm_transaction(&transaction))
+            .when(|e| {
+                !matches!(
+                    e.kind,
+                    ClientErrorKind::TransactionError(_) | ClientErrorKind::SigningError(_)
+                )
+            })
+            .call()
             .map_err(|e| {
-                let msg = format!("failed to submit transaction: {e}");
+                let msg = format!("failed to send transaction: {e}");
                 error!(msg);
                 anyhow!(msg)
-            })
+            })?;
+
+        Ok(signature.to_string())
     }
 }
 
@@ -323,8 +335,8 @@ impl<'a> CollectionBackend for UncompressedRef<'a> {
         );
         let len = spl_token::state::Mint::LEN;
 
-        let rent = call_with_retry!(rpc.get_minimum_balance_for_rent_exemption(len))?;
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let rent = with_retry!(rpc.get_minimum_balance_for_rent_exemption(len)).call()?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let create_account_ins = solana_program::system_instruction::create_account(
             &payer,
@@ -473,7 +485,7 @@ impl<'a> CollectionBackend for UncompressedRef<'a> {
             None,
         );
 
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let message =
             solana_program::message::Message::new_with_blockhash(&[ins], Some(&payer), &blockhash);
@@ -525,7 +537,7 @@ impl<'a> CollectionBackend for UncompressedRef<'a> {
             &mpl_token_metadata::ID,
         );
 
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let update_ins: Instruction = mpl_token_metadata::instruction::update_metadata_accounts_v2(
             mpl_token_metadata::ID,
@@ -588,7 +600,7 @@ impl<'a> CollectionBackend for UncompressedRef<'a> {
         let mut message: solana_program::message::Message =
             bincode::deserialize(&revision.serialized_message)?;
 
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
         message.recent_blockhash = blockhash;
 
         Ok(TransactionResponse {
@@ -673,7 +685,7 @@ impl<'a> CollectionBackend for UncompressedRef<'a> {
 
         let instructions = vec![unverify_ins, verify_ins];
 
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let message = solana_program::message::Message::new_with_blockhash(
             &instructions,
@@ -743,7 +755,8 @@ impl<'a> MintBackend<MintMetaplexEditionTransaction, MintEditionAddresses> for E
         ];
         let (metadata_key, _) = Pubkey::find_program_address(metadata_seeds, &program_pubkey);
 
-        let rent = call_with_retry!(rpc.get_minimum_balance_for_rent_exemption(state::Mint::LEN))?;
+        let rent =
+            with_retry!(rpc.get_minimum_balance_for_rent_exemption(state::Mint::LEN)).call()?;
 
         let mut instructions = vec![
             create_account(
@@ -781,7 +794,7 @@ impl<'a> MintBackend<MintMetaplexEditionTransaction, MintEditionAddresses> for E
             edition,
         ));
 
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let message = solana_program::message::Message::new_with_blockhash(
             &instructions,
@@ -829,7 +842,7 @@ impl<'a> TransferBackend<collection_mints::Model, TransferAssetAddresses> for Un
         let recipient: Pubkey = recipient_address.parse()?;
         let mint_address: Pubkey = collection_mint.mint.parse()?;
         let payer: Pubkey = self.0.treasury_wallet_address;
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
         let source_ata = get_associated_token_address(&sender, &mint_address);
         let destination_ata = get_associated_token_address(&recipient, &mint_address);
 
@@ -1126,8 +1139,8 @@ impl<'a> MintBackend<MintMetaplexMetadataTransaction, MintMetaplexAddresses>
         );
         let associated_token_account = get_associated_token_address(&recipient, &mint.pubkey());
         let len = spl_token::state::Mint::LEN;
-        let rent = call_with_retry!(rpc.get_minimum_balance_for_rent_exemption(len))?;
-        let blockhash = call_with_retry!(rpc.get_latest_blockhash())?;
+        let rent = with_retry!(rpc.get_minimum_balance_for_rent_exemption(len)).call()?;
+        let blockhash = with_retry!(rpc.get_latest_blockhash()).call()?;
 
         let create_account_ins = solana_program::system_instruction::create_account(
             &payer,

core/src/db.rs

@@ -12,7 +12,7 @@ pub struct DbArgs {
     pub connection_timeout: u64,
     #[arg(long, env, default_value_t = 10)]
     pub acquire_timeout: u64,
-    #[arg(long, env, default_value_t = 60)]
+    #[arg(long, env, default_value_t = 10)]
     pub idle_timeout: u64,
     #[arg(long, env)]
     pub database_url: String,

indexer/Cargo.toml

@@ -25,12 +25,10 @@ solana-program = "1.14"
 anchor-lang = "0.26.0"
 yellowstone-grpc-client = { git = "https://github.com/rpcpool/yellowstone-grpc", tag = "v1.7.1+solana.1.16.1" }
 yellowstone-grpc-proto = { git = "https://github.com/rpcpool/yellowstone-grpc", tag = "v1.7.1+solana.1.16.1" }
-dashmap = "5.4.0"
 spl-token = "=3.5.0"
 solana-client = "1.14"
 backoff = { version = "0.4.0", features = ["tokio"] }
 
-
 [dependencies.hub-core]
 package = "holaplex-hub-core"
 version = "0.5.6"