Merge branch 'main' into pyth-stylus-governance-impl

Author: ayushboss

.github/workflows/ci-lazer-rust.yml

@@ -41,6 +41,12 @@ jobs:
       - name: Clippy check
         run: cargo clippy -p pyth-lazer-protocol -p pyth-lazer-client -p pyth-lazer-publisher-sdk --all-targets -- --deny warnings
         if: success() || failure()
+      - name: Clippy check with mry
+        run: cargo clippy -F mry -p pyth-lazer-protocol --all-targets -- --deny warnings
+        if: success() || failure()
       - name: test
         run: cargo test -p pyth-lazer-protocol -p pyth-lazer-client -p pyth-lazer-publisher-sdk
         if: success() || failure()
+      - name: test with mry
+        run: cargo test -F mry -p pyth-lazer-protocol
+        if: success() || failure()

Cargo.lock

@@ -1,6 +1,6 @@
 {
   "name": "@pythnetwork/entropy-tester",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Utility to test entropy provider callbacks",
   "private": true,
   "type": "module",

apps/entropy-tester/package.json

@@ -11,9 +11,12 @@ import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { z } from "zod";
 
+const DEFAULT_RETRIES = 3;
+
 type LoadedConfig = {
   contract: EvmEntropyContract;
   interval: number;
+  retries: number;
 };
 
 function timeToSeconds(timeStr: string): number {
@@ -46,6 +49,7 @@ async function loadConfig(configPath: string): Promise<LoadedConfig[]> {
       "chain-id": z.string(),
       interval: z.string(),
       "rpc-endpoint": z.string().optional(),
+      retries: z.number().default(DEFAULT_RETRIES),
     }),
   );
   const configContent = (await import(configPath, {
@@ -78,7 +82,7 @@ async function loadConfig(configPath: string): Promise<LoadedConfig[]> {
         evmChain.networkId,
       );
     }
-    return { contract: firstContract, interval };
+    return { contract: firstContract, interval, retries: config.retries };
   });
   return loadedConfigs;
 }
@@ -188,31 +192,63 @@ export const main = function () {
           privateKeyFileContent.replace("0x", "").trimEnd(),
         );
         logger.info("Running");
-        const promises = configs.map(async ({ contract, interval }) => {
-          const child = logger.child({ chain: contract.chain.getId() });
-          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          while (true) {
-            try {
-              await Promise.race([
-                testLatency(contract, privateKey, child),
-                new Promise((_, reject) =>
-                  setTimeout(() => {
-                    reject(
-                      new Error(
-                        "Timeout: 120s passed but testLatency function was not resolved",
-                      ),
+        const promises = configs.map(
+          async ({ contract, interval, retries }) => {
+            const child = logger.child({ chain: contract.chain.getId() });
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            while (true) {
+              let lastError: Error | undefined;
+              let success = false;
+
+              for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                  await Promise.race([
+                    testLatency(contract, privateKey, child),
+                    new Promise((_, reject) =>
+                      setTimeout(() => {
+                        reject(
+                          new Error(
+                            "Timeout: 120s passed but testLatency function was not resolved",
+                          ),
+                        );
+                      }, 120_000),
+                    ),
+                  ]);
+                  success = true;
+                  break;
+                } catch (error) {
+                  lastError = error as Error;
+                  child.warn(
+                    { attempt, maxRetries: retries, error: error },
+                    `Attempt ${attempt.toString()}/${retries.toString()} failed, ${attempt < retries ? "retrying..." : "all retries exhausted"}`,
+                  );
+
+                  if (attempt < retries) {
+                    // Wait a bit before retrying (exponential backoff, max 10s)
+                    const backoffDelay = Math.min(
+                      2000 * Math.pow(2, attempt - 1),
+                      10_000,
+                    );
+                    await new Promise((resolve) =>
+                      setTimeout(resolve, backoffDelay),
                     );
-                  }, 120_000),
-                ),
-              ]);
-            } catch (error) {
-              child.error(error, "Error testing latency");
+                  }
+                }
+              }
+
+              if (!success && lastError) {
+                child.error(
+                  { error: lastError, retriesExhausted: retries },
+                  "All retries exhausted, callback was not called.",
+                );
+              }
+
+              await new Promise((resolve) =>
+                setTimeout(resolve, interval * 1000),
+              );
             }
-            await new Promise((resolve) =>
-              setTimeout(resolve, interval * 1000),
-            );
-          }
-        });
+          },
+        );
         await Promise.all(promises);
       },
     )

apps/entropy-tester/src/index.ts

@@ -1,6 +1,6 @@
 [package]
 name = "fortuna"
-version = "8.2.0"
+version = "8.2.1"
 edition = "2021"
 
 [lib]

apps/fortuna/Cargo.toml

@@ -8,7 +8,7 @@ use {
     ethers::{
         contract::{ContractCall, ContractError},
         middleware::Middleware,
-        providers::ProviderError,
+        providers::{MiddlewareError, ProviderError},
         signers::Signer,
         types::{
             transaction::eip2718::TypedTransaction, TransactionReceipt, TransactionRequest, U256,
@@ -253,7 +253,19 @@ pub async fn submit_tx<T: Middleware + NonceManaged + 'static>(
     client
         .fill_transaction(&mut transaction, None)
         .await
-        .map_err(|e| backoff::Error::transient(SubmitTxError::GasPriceEstimateError(e)))?;
+        .map_err(|e| {
+            // If there is revert data, the contract reverted during gas usage estimation.
+            if let Some(e) = e.as_error_response() {
+                if let Some(e) = e.as_revert_data() {
+                    return backoff::Error::transient(SubmitTxError::GasUsageEstimateError(
+                        ContractError::Revert(e.clone()),
+                    ));
+                }
+            }
+
+            // If there is no revert data, there was likely an error during gas price polling.
+            backoff::Error::transient(SubmitTxError::GasPriceEstimateError(e))
+        })?;
 
     // Apply the fee escalation policy. Note: the unwrap_or_default should never default as we have a gas oracle
     // in the client that sets the gas price.

apps/fortuna/src/eth_utils/utils.rs

@@ -357,7 +357,18 @@ impl History {
             }
         };
         if let Err(e) = result {
-            tracing::error!("Failed to update request status: {}", e);
+            match e.as_database_error() {
+                Some(db_error) if db_error.is_unique_violation() => {
+                    tracing::info!(
+                        "Failed to insert request, request already exists: Chain ID: {}, Sequence: {}",
+                        network_id,
+                        sequence
+                    );
+                }
+                _ => {
+                    tracing::error!("Failed to update request status: {}", e);
+                }
+            }
         }
     }
 

apps/fortuna/src/history.rs

@@ -44,6 +44,13 @@ async fn calculate_fair_fee_withdrawal_amount<M: Middleware + 'static>(
         .await
         .map_err(|e| anyhow!("Error while getting current keeper balance. error: {:?}", e))?;
 
+    tracing::info!(
+        "Contract has available fees: {:?}, current keeper ({:?}) has balance: {:?}",
+        available_fees,
+        keeper_address,
+        current_balance
+    );
+
     // Calculate total funds across all keepers + available fees
     let mut total_funds = current_balance + available_fees;
 
@@ -55,6 +62,7 @@ async fn calculate_fair_fee_withdrawal_amount<M: Middleware + 'static>(
                 e
             )
         })?;
+        tracing::info!("Keeper address {:?} has balance: {:?}", address, balance);
         total_funds += balance;
     }
 
@@ -174,7 +182,7 @@ pub async fn withdraw_fees_if_necessary(
     if withdrawal_amount < min_withdrawal_amount {
         // We don't have enough to meaningfully top up the balance.
         // NOTE: This log message triggers a grafana alert. If you want to change the text, please change the alert also.
-        tracing::warn!("Keeper balance {:?} is too low (< {:?}) but provider fees are not sufficient to top-up.", keeper_balance, min_balance);
+        tracing::warn!("Keeper balance {:?} is too low (< {:?}) but provider fees are not sufficient to top-up. (withdrawal_amount={:?} < min_withdrawal_amount={:?})", keeper_balance, min_balance, withdrawal_amount, min_withdrawal_amount);
         return Ok(());
     }
 

apps/fortuna/src/keeper/fee.rs

@@ -1,6 +1,6 @@
 {
   "name": "@pythnetwork/staking-sdk",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Pyth staking SDK",
   "type": "module",
   "exports": {
@@ -13,7 +13,7 @@
     "dist/**/*"
   ],
   "engines": {
-    "node": "20 || 22"
+    "node": "20 || 22 || 24"
   },
   "publishConfig": {
     "access": "public"