ваше сообщение коммита

backend/utils/deploymentUtils.js

@@ -55,69 +55,7 @@ function createProviderAndWallet(rpcUrl, privateKey) {
   }
 }
 
-/**
- * Выравнивает nonce до целевого значения
- * @param {Object} wallet - Кошелек ethers
- * @param {Object} provider - Провайдер ethers
- * @param {number} targetNonce - Целевой nonce
- * @param {Object} options - Опции для настройки
- * @returns {Promise<number>} - Текущий nonce после выравнивания
- */
-async function alignNonce(wallet, provider, targetNonce, options = {}) {
-  try {
-    // Используем nonceManager для получения актуального nonce
-    const network = await provider.getNetwork();
-    const chainId = Number(network.chainId);
-    const rpcUrl = provider._getConnection?.()?.url || 'unknown';
-    
-    let current = await nonceManager.getNonceFast(wallet.address, rpcUrl, chainId);
-    
-    if (current > targetNonce) {
-      throw new Error(`Current nonce ${current} > target nonce ${targetNonce}`);
-    }
-    
-    if (current < targetNonce) {
-      logger.info(`Выравнивание nonce: ${current} -> ${targetNonce} (${targetNonce - current} транзакций)`);
-      
-      const { burnAddress = '0x000000000000000000000000000000000000dEaD' } = options;
-      
-      for (let i = current; i < targetNonce; i++) {
-        const overrides = await getFeeOverrides(provider);
-        const gasLimit = 21000n;
-        
-        try {
-          const txFill = await wallet.sendTransaction({
-            to: burnAddress,
-            value: 0,
-            gasLimit,
-            ...overrides
-          });
-          
-          logger.info(`Filler tx sent, hash=${txFill.hash}, nonce=${i}`);
-          
-          await txFill.wait();
-          logger.info(`Filler tx confirmed, hash=${txFill.hash}, nonce=${i}`);
-          
-          // Обновляем nonce в кэше
-          nonceManager.reserveNonce(wallet.address, chainId, i);
-          current = i + 1;
-        } catch (error) {
-          logger.error(`Filler tx failed for nonce=${i}:`, error);
-          throw error;
-        }
-      }
-      
-      logger.info(`Nonce alignment completed, current nonce=${current}`);
-    } else {
-      logger.info(`Nonce already aligned at ${current}`);
-    }
-    
-    return current;
-  } catch (error) {
-    logger.error('Ошибка при выравнивании nonce:', error);
-    throw error;
-  }
-}
+// alignNonce функция удалена - используем nonceManager.alignNonceToTarget() вместо этого
 
 /**
  * Получает информацию о сети
@@ -177,50 +115,15 @@ async function createMultipleRPCConnections(rpcUrls, privateKey, options = {}) {
   return await rpcManager.createMultipleConnections(rpcUrls, privateKey, options);
 }
 
-/**
- * Выполняет транзакцию с retry логикой
- * @param {Object} wallet - Кошелек
- * @param {Object} txData - Данные транзакции
- * @param {Object} options - Опции
- * @returns {Promise<Object>} - Результат транзакции
- */
-async function sendTransactionWithRetry(wallet, txData, options = {}) {
-  const rpcManager = new RPCConnectionManager();
-  return await rpcManager.sendTransactionWithRetry(wallet, txData, options);
-}
+// sendTransactionWithRetry функция удалена - используем RPCConnectionManager напрямую
 
-/**
- * Получает nonce с retry логикой
- * @param {Object} provider - Провайдер
- * @param {string} address - Адрес
- * @param {Object} options - Опции
- * @returns {Promise<number>} - Nonce
- */
-async function getNonceWithRetry(provider, address, options = {}) {
-  // Используем быстрый метод по умолчанию
-  if (options.fast !== false) {
-    try {
-      const network = await provider.getNetwork();
-      const chainId = Number(network.chainId);
-      const rpcUrl = provider._getConnection?.()?.url || 'unknown';
-      return await nonceManager.getNonceFast(address, rpcUrl, chainId);
-    } catch (error) {
-      console.warn(`[deploymentUtils] Быстрый nonce failed, используем retry: ${error.message}`);
-    }
-  }
-  
-  // Fallback на retry метод
-  return await nonceManager.getNonceWithRetry(provider, address, options);
-}
+// getNonceWithRetry функция удалена - используем nonceManager.getNonceWithRetry() вместо этого
 
 module.exports = {
   getFeeOverrides,
   createProviderAndWallet,
-  alignNonce,
   getNetworkInfo,
   getBalance,
   createRPCConnection,
-  createMultipleRPCConnections,
-  sendTransactionWithRetry,
-  getNonceWithRetry
+  createMultipleRPCConnections
 };

backend/utils/nonceManager.js

@@ -21,13 +21,16 @@ class NonceManager {
    * @returns {Promise<number>} - Актуальный nonce
    */
   async getNonce(address, rpcUrl, chainId, options = {}) {
-    const { timeout = 10000, maxRetries = 3 } = options; // Увеличиваем таймаут и попытки
+    const { timeout = 15000, maxRetries = 5 } = options; // Увеличиваем таймаут и попытки
     
     const cacheKey = `${address}-${chainId}`;
     
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        const provider = new ethers.JsonRpcProvider(rpcUrl);
+        const provider = new ethers.JsonRpcProvider(rpcUrl, undefined, {
+          polling: false, // Отключаем polling для более быстрого получения nonce
+          staticNetwork: true
+        });
         
         // Получаем nonce из сети с таймаутом
         const networkNonce = await Promise.race([
@@ -170,51 +173,7 @@ class NonceManager {
     };
   }
 
-  /**
-   * Быстрое получение nonce без retry (для критичных по времени операций)
-   * @param {string} address - Адрес кошелька
-   * @param {string} rpcUrl - RPC URL сети
-   * @param {number} chainId - ID сети
-   * @returns {Promise<number>} - Nonce
-   */
-  async getNonceFast(address, rpcUrl, chainId) {
-    const cacheKey = `${address}-${chainId}`;
-    const cachedNonce = this.nonceCache.get(cacheKey);
-    
-    if (cachedNonce !== undefined) {
-      console.log(`[NonceManager] Быстрый nonce из кэша: ${cachedNonce} для ${address}:${chainId}`);
-      return cachedNonce;
-    }
-    
-    // Получаем RPC URLs из базы данных с fallback
-    const rpcUrls = await this.getRpcUrlsFromDatabase(chainId, rpcUrl);
-    
-    for (const currentRpc of rpcUrls) {
-      try {
-        console.log(`[NonceManager] Пробуем RPC: ${currentRpc}`);
-        const provider = new ethers.JsonRpcProvider(currentRpc);
-        
-        const networkNonce = await Promise.race([
-          provider.getTransactionCount(address, 'pending'),
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Fast nonce timeout')), 3000)
-          )
-        ]);
-        
-        this.nonceCache.set(cacheKey, networkNonce);
-        console.log(`[NonceManager] ✅ Nonce получен: ${networkNonce} для ${address}:${chainId} с RPC: ${currentRpc}`);
-        return networkNonce;
-      } catch (error) {
-        console.warn(`[NonceManager] RPC failed: ${currentRpc} - ${error.message}`);
-        continue;
-      }
-    }
-    
-    // Если все RPC недоступны, возвращаем 0
-    console.warn(`[NonceManager] Все RPC недоступны для ${address}:${chainId}, возвращаем 0`);
-    this.nonceCache.set(cacheKey, 0);
-    return 0;
-  }
+  // getNonceFast функция удалена - используем getNonce() вместо этого
 
   /**
    * Получить RPC URLs из базы данных с fallback
@@ -330,6 +289,75 @@ class NonceManager {
       throw error;
     }
   }
+
+  /**
+   * Выровнять nonce до целевого значения с помощью filler транзакций
+   * @param {string} address - Адрес кошелька
+   * @param {string} rpcUrl - RPC URL сети
+   * @param {number} chainId - ID сети
+   * @param {number} targetNonce - Целевой nonce
+   * @param {Object} wallet - Кошелек для отправки транзакций
+   * @param {Object} options - Опции (gasLimit, maxRetries)
+   * @returns {Promise<number>} - Финальный nonce
+   */
+  async alignNonceToTarget(address, rpcUrl, chainId, targetNonce, wallet, options = {}) {
+    const { gasLimit = 21000, maxRetries = 5 } = options;
+    const burnAddress = "0x000000000000000000000000000000000000dEaD";
+    
+    // Получаем текущий nonce
+    let current = await this.getNonce(address, rpcUrl, chainId, { timeout: 15000, maxRetries: 5 });
+    console.log(`[NonceManager] Aligning nonce ${current} -> ${targetNonce} for ${address}:${chainId}`);
+    
+    if (current >= targetNonce) {
+      console.log(`[NonceManager] Nonce already aligned: ${current} >= ${targetNonce}`);
+      return current;
+    }
+    
+    // Используем RPCConnectionManager для retry логики
+    const RPCConnectionManager = require('./rpcConnectionManager');
+    const rpcManager = new RPCConnectionManager();
+    
+    // Выравниваем nonce с помощью filler транзакций
+    while (current < targetNonce) {
+      console.log(`[NonceManager] Sending filler tx nonce=${current} for ${address}:${chainId}`);
+      
+      try {
+        const txData = {
+          to: burnAddress,
+          value: 0n,
+          nonce: current,
+          gasLimit,
+        };
+        
+        const result = await rpcManager.sendTransactionWithRetry(wallet, txData, { maxRetries });
+        console.log(`[NonceManager] Filler tx sent: ${result.tx.hash} for nonce=${current}`);
+        current++;
+        
+      } catch (e) {
+        const errorMsg = e?.message || e;
+        console.warn(`[NonceManager] Filler tx failed: ${errorMsg}`);
+        
+        // Обрабатываем ошибки nonce
+        if (String(errorMsg).toLowerCase().includes('nonce too low')) {
+          this.resetNonce(address, chainId);
+          const newNonce = await this.getNonce(address, rpcUrl, chainId, { timeout: 15000, maxRetries: 5 });
+          console.log(`[NonceManager] Nonce changed from ${current} to ${newNonce}`);
+          current = newNonce;
+          
+          if (current >= targetNonce) {
+            console.log(`[NonceManager] Nonce alignment completed: ${current} >= ${targetNonce}`);
+            return current;
+          }
+          continue;
+        }
+        
+        throw new Error(`Failed to send filler tx for nonce=${current}: ${errorMsg}`);
+      }
+    }
+    
+    console.log(`[NonceManager] Nonce alignment completed: ${current} for ${address}:${chainId}`);
+    return current;
+  }
 }
 
 // Создаем глобальный экземпляр

backend/utils/rpcConnectionManager.js

@@ -192,40 +192,7 @@ class RPCConnectionManager {
     );
   }
 
-  /**
-   * Получает nonce с retry логикой
-   * @param {Object} provider - Провайдер
-   * @param {string} address - Адрес
-   * @param {Object} options - Опции
-   * @returns {Promise<number>} - Nonce
-   */
-  async getNonceWithRetry(provider, address, options = {}) {
-    const config = { ...this.retryConfig, ...options };
-    
-    for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-      try {
-        const nonce = await Promise.race([
-          provider.getTransactionCount(address, 'pending'),
-          new Promise((_, reject) => 
-            setTimeout(() => reject(new Error('Nonce timeout')), config.timeout)
-          )
-        ]);
-        
-        logger.info(`[RPC_MANAGER] ✅ Nonce получен: ${nonce} (попытка ${attempt})`);
-        return nonce;
-        
-      } catch (error) {
-        logger.error(`[RPC_MANAGER] ❌ Nonce failed (попытка ${attempt}): ${error.message}`);
-        
-        if (attempt === config.maxRetries) {
-          throw new Error(`Не удалось получить nonce после ${config.maxRetries} попыток: ${error.message}`);
-        }
-        
-        const delay = Math.min(config.baseDelay * Math.pow(2, attempt - 1), config.maxDelay);
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
-    }
-  }
+  // getNonceWithRetry функция удалена - используем nonceManager.getNonceWithRetry() вместо этого
 
   /**
    * Очищает кэш соединений