ваше сообщение коммита
This commit is contained in:
@@ -21,6 +21,9 @@ const { nonceManager } = require('../../utils/nonceManager');
|
||||
// WebSocket сервис для отслеживания деплоя
|
||||
const deploymentWebSocketService = require('../../services/deploymentWebSocketService');
|
||||
|
||||
// Сервис для верификации контрактов
|
||||
// ContractVerificationService удален - используем Hardhat verify
|
||||
|
||||
// Конфигурация модулей для деплоя
|
||||
const MODULE_CONFIGS = {
|
||||
treasury: {
|
||||
@@ -71,6 +74,107 @@ const MODULE_CONFIGS = {
|
||||
// }
|
||||
};
|
||||
|
||||
// Функция для определения имени сети Hardhat по chainId
|
||||
function getNetworkNameForHardhat(chainId) {
|
||||
const networkMapping = {
|
||||
11155111: 'sepolia',
|
||||
17000: 'holesky',
|
||||
421614: 'arbitrumSepolia',
|
||||
84532: 'baseSepolia',
|
||||
1: 'mainnet',
|
||||
42161: 'arbitrumOne',
|
||||
8453: 'base',
|
||||
137: 'polygon',
|
||||
56: 'bsc'
|
||||
};
|
||||
|
||||
const hardhatNetworkName = networkMapping[chainId];
|
||||
if (!hardhatNetworkName) {
|
||||
logger.warn(`⚠️ Сеть ${chainId} не поддерживается в Hardhat`);
|
||||
return null;
|
||||
}
|
||||
|
||||
logger.info(`✅ Сеть ${chainId} поддерживается: ${hardhatNetworkName}`);
|
||||
return hardhatNetworkName;
|
||||
}
|
||||
|
||||
// Функция для автоматической верификации модуля
|
||||
async function verifyModuleAfterDeploy(chainId, contractAddress, moduleType, constructorArgs, apiKey) {
|
||||
try {
|
||||
if (!apiKey) {
|
||||
logger.warn(`⚠️ API ключ Etherscan не предоставлен, пропускаем верификацию модуля ${moduleType}`);
|
||||
return { success: false, error: 'API ключ не предоставлен' };
|
||||
}
|
||||
|
||||
logger.info(`🔍 Начинаем верификацию модуля ${moduleType} по адресу ${contractAddress} в сети ${chainId}`);
|
||||
|
||||
// Используем Hardhat verify вместо старого сервиса
|
||||
const { exec } = require('child_process');
|
||||
const { promisify } = require('util');
|
||||
const execAsync = promisify(exec);
|
||||
|
||||
// Определяем имя сети для Hardhat
|
||||
const networkName = getNetworkNameForHardhat(chainId);
|
||||
if (!networkName) {
|
||||
logger.warn(`⚠️ Неизвестная сеть ${chainId}, пропускаем верификацию модуля ${moduleType}`);
|
||||
return { success: false, error: `Неизвестная сеть ${chainId}` };
|
||||
}
|
||||
|
||||
logger.info(`🔧 Используем Hardhat verify для модуля ${moduleType} в сети ${networkName}`);
|
||||
|
||||
// Создаем временный файл с аргументами конструктора
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const tempArgsFile = path.join(__dirname, '..', '..', `temp-module-args-${moduleType}.js`);
|
||||
|
||||
// Конвертируем аргументы в строки для JSON сериализации
|
||||
const serializableArgs = constructorArgs.map(arg => {
|
||||
if (typeof arg === 'bigint') {
|
||||
return arg.toString();
|
||||
}
|
||||
return arg;
|
||||
});
|
||||
|
||||
const argsContent = `module.exports = ${JSON.stringify(serializableArgs, null, 2)};`;
|
||||
fs.writeFileSync(tempArgsFile, argsContent);
|
||||
|
||||
try {
|
||||
// Выполняем Hardhat verify
|
||||
const command = `npx hardhat verify --network ${networkName} --constructor-args ${tempArgsFile} ${contractAddress}`;
|
||||
logger.info(`🔧 Выполняем команду: ${command}`);
|
||||
|
||||
// Устанавливаем переменные окружения для Hardhat
|
||||
const envVars = {
|
||||
...process.env,
|
||||
ETHERSCAN_API_KEY: apiKey
|
||||
};
|
||||
|
||||
const { stdout, stderr } = await execAsync(command, {
|
||||
cwd: path.join(__dirname, '..', '..'),
|
||||
env: envVars
|
||||
});
|
||||
|
||||
if (stdout.includes('Successfully verified')) {
|
||||
logger.info(`✅ Модуль ${moduleType} успешно верифицирован через Hardhat!`);
|
||||
logger.info(`📄 Вывод: ${stdout}`);
|
||||
return { success: true, message: 'Верификация успешна' };
|
||||
} else {
|
||||
logger.error(`❌ Ошибка верификации модуля ${moduleType}: ${stderr || stdout}`);
|
||||
return { success: false, error: stderr || stdout };
|
||||
}
|
||||
} finally {
|
||||
// Удаляем временный файл
|
||||
if (fs.existsSync(tempArgsFile)) {
|
||||
fs.unlinkSync(tempArgsFile);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
logger.error(`❌ Ошибка при верификации модуля ${moduleType}: ${error.message}`);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
// Деплой модуля в одной сети с CREATE2
|
||||
async function deployModuleInNetwork(rpcUrl, pk, salt, initCodeHash, targetNonce, moduleInit, moduleType) {
|
||||
const { ethers } = hre;
|
||||
@@ -345,6 +449,49 @@ async function deployAllModulesInNetwork(rpcUrl, pk, salt, dleAddress, modulesTo
|
||||
const result = await deployModuleInNetwork(rpcUrl, pk, salt, null, targetNonce, moduleInit, moduleType);
|
||||
results[moduleType] = { ...result, success: true };
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'success', `Модуль ${moduleType} успешно задеплоен в сети ${net.name || net.chainId}: ${result.address}`);
|
||||
|
||||
// Автоматическая верификация после успешного деплоя
|
||||
if (result.address && params.etherscanApiKey && params.autoVerifyAfterDeploy) {
|
||||
try {
|
||||
logger.info(`🔍 Начинаем автоматическую верификацию модуля ${moduleType}...`);
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'info', `Начинаем верификацию модуля ${moduleType} в Etherscan...`);
|
||||
|
||||
// Получаем аргументы конструктора для модуля
|
||||
const moduleConfig = MODULE_CONFIGS[moduleType];
|
||||
const constructorArgs = moduleConfig.constructorArgs(dleAddress, Number(net.chainId), walletAddress);
|
||||
|
||||
const verificationResult = await verifyModuleAfterDeploy(
|
||||
Number(net.chainId),
|
||||
result.address,
|
||||
moduleType,
|
||||
constructorArgs,
|
||||
params.etherscanApiKey
|
||||
);
|
||||
|
||||
if (verificationResult.success) {
|
||||
results[moduleType].verification = 'verified';
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'success', `Модуль ${moduleType} успешно верифицирован в Etherscan!`);
|
||||
logger.info(`✅ Модуль ${moduleType} верифицирован: ${result.address}`);
|
||||
} else {
|
||||
results[moduleType].verification = 'failed';
|
||||
results[moduleType].verificationError = verificationResult.error || verificationResult.message;
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'warning', `Верификация модуля ${moduleType} не удалась: ${verificationResult.error || verificationResult.message}`);
|
||||
logger.warn(`⚠️ Верификация модуля ${moduleType} не удалась: ${verificationResult.error || verificationResult.message}`);
|
||||
}
|
||||
} catch (verificationError) {
|
||||
results[moduleType].verification = 'error';
|
||||
results[moduleType].verificationError = verificationError.message;
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'warning', `Ошибка при верификации модуля ${moduleType}: ${verificationError.message}`);
|
||||
logger.error(`❌ Ошибка при верификации модуля ${moduleType}: ${verificationError.message}`);
|
||||
}
|
||||
} else {
|
||||
results[moduleType].verification = 'skipped';
|
||||
if (!params.etherscanApiKey) {
|
||||
logger.info(`ℹ️ API ключ Etherscan не предоставлен, пропускаем верификацию модуля ${moduleType}`);
|
||||
} else if (!params.autoVerifyAfterDeploy) {
|
||||
logger.info(`ℹ️ Автоматическая верификация отключена, пропускаем верификацию модуля ${moduleType}`);
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error(`[MODULES_DBG] chainId=${Number(net.chainId)} ${moduleType} deployment failed:`, error.message);
|
||||
results[moduleType] = {
|
||||
@@ -616,40 +763,16 @@ async function main() {
|
||||
logger.info(`[MODULES_DBG] SUCCESS: All ${moduleType} addresses are identical:`, uniqueAddresses[0]);
|
||||
}
|
||||
|
||||
// Верификация во всех сетях через отдельный скрипт
|
||||
logger.info(`[MODULES_DBG] Starting verification in all networks...`);
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'info', 'Начало верификации модулей во всех сетях...');
|
||||
|
||||
// Запускаем верификацию модулей через существующий скрипт
|
||||
try {
|
||||
const { verifyModules } = require('../verify-with-hardhat-v2');
|
||||
|
||||
logger.info(`[MODULES_DBG] Запускаем верификацию модулей...`);
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'info', 'Верификация контрактов в блокчейн-сканерах...');
|
||||
await verifyModules();
|
||||
logger.info(`[MODULES_DBG] Верификация модулей завершена`);
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'success', 'Верификация модулей завершена успешно');
|
||||
} catch (verifyError) {
|
||||
logger.info(`[MODULES_DBG] Ошибка при верификации модулей: ${verifyError.message}`);
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'error', `Ошибка при верификации модулей: ${verifyError.message}`);
|
||||
}
|
||||
|
||||
// Создаем результаты верификации (все как успешные, так как верификация выполняется отдельно)
|
||||
const verificationResults = deployResults.map(result => ({
|
||||
chainId: result.chainId,
|
||||
modules: Object.keys(result.modules || {}).reduce((acc, moduleType) => {
|
||||
acc[moduleType] = 'success';
|
||||
return acc;
|
||||
}, {})
|
||||
}));
|
||||
// Верификация модулей теперь интегрирована в основной процесс деплоя
|
||||
// Автоматическая верификация происходит в функции deployAllModulesInNetwork
|
||||
logger.info(`[MODULES_DBG] Верификация модулей интегрирована в процесс деплоя`);
|
||||
|
||||
// Объединяем результаты
|
||||
const finalResults = deployResults.map((deployResult, index) => ({
|
||||
...deployResult,
|
||||
modules: deployResult.modules ? Object.keys(deployResult.modules).reduce((acc, moduleType) => {
|
||||
acc[moduleType] = {
|
||||
...deployResult.modules[moduleType],
|
||||
verification: verificationResults[index]?.modules?.[moduleType] || 'unknown'
|
||||
...deployResult.modules[moduleType]
|
||||
};
|
||||
return acc;
|
||||
}, {}) : {}
|
||||
|
||||
@@ -43,22 +43,193 @@ console.log('[MULTI_DBG] 📦 Импортируем nonceManager...');
|
||||
const { nonceManager } = require('../../utils/nonceManager');
|
||||
console.log('[MULTI_DBG] ✅ nonceManager импортирован');
|
||||
|
||||
// ContractVerificationService удален - используем Hardhat verify
|
||||
|
||||
console.log('[MULTI_DBG] 🎯 ВСЕ ИМПОРТЫ УСПЕШНЫ!');
|
||||
|
||||
console.log('[MULTI_DBG] 🔍 ПРОВЕРЯЕМ ФУНКЦИИ...');
|
||||
console.log('[MULTI_DBG] deployInNetwork:', typeof deployInNetwork);
|
||||
console.log('[MULTI_DBG] main:', typeof main);
|
||||
|
||||
async function deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, dleInit, params) {
|
||||
const { ethers } = hre;
|
||||
// Функция для получения имени сети для Hardhat из deploy_params
|
||||
function getNetworkNameForHardhat(chainId, params) {
|
||||
// Создаем маппинг chainId -> Hardhat network name
|
||||
const networkMapping = {
|
||||
11155111: 'sepolia',
|
||||
17000: 'holesky',
|
||||
421614: 'arbitrumSepolia',
|
||||
84532: 'baseSepolia',
|
||||
1: 'mainnet',
|
||||
42161: 'arbitrumOne',
|
||||
8453: 'base',
|
||||
137: 'polygon',
|
||||
56: 'bsc'
|
||||
};
|
||||
|
||||
// Используем новый менеджер RPC с retry логикой
|
||||
const { provider, wallet, network } = await createRPCConnection(rpcUrl, pk, {
|
||||
maxRetries: 3,
|
||||
timeout: 30000
|
||||
});
|
||||
// Проверяем, поддерживается ли сеть в Hardhat
|
||||
const hardhatNetworkName = networkMapping[chainId];
|
||||
if (!hardhatNetworkName) {
|
||||
logger.warn(`⚠️ Сеть ${chainId} не поддерживается в Hardhat`);
|
||||
return null;
|
||||
}
|
||||
|
||||
const net = network;
|
||||
// Проверяем, есть ли эта сеть в supported_chain_ids из deploy_params
|
||||
const supportedChainIds = params.supported_chain_ids || params.supportedChainIds || [];
|
||||
if (supportedChainIds.length > 0) {
|
||||
// Преобразуем supportedChainIds в числа для сравнения
|
||||
const supportedChainIdsNumbers = supportedChainIds.map(id => Number(id));
|
||||
if (!supportedChainIdsNumbers.includes(chainId)) {
|
||||
logger.warn(`⚠️ Сеть ${chainId} не входит в список поддерживаемых сетей: ${supportedChainIdsNumbers.join(', ')}`);
|
||||
return null;
|
||||
}
|
||||
logger.info(`✅ Сеть ${chainId} найдена в списке поддерживаемых сетей`);
|
||||
} else {
|
||||
logger.info(`ℹ️ Список поддерживаемых сетей пуст, разрешаем верификацию для ${chainId}`);
|
||||
}
|
||||
|
||||
logger.info(`✅ Сеть ${chainId} поддерживается: ${hardhatNetworkName}`);
|
||||
logger.info(`🔍 Детали сети: chainId=${chainId}, hardhatName=${hardhatNetworkName}, supportedChains=[${supportedChainIds.join(', ')}]`);
|
||||
return hardhatNetworkName;
|
||||
}
|
||||
|
||||
// Функция для автоматической верификации DLE контракта
|
||||
async function verifyDLEAfterDeploy(chainId, contractAddress, constructorArgs, apiKey, params) {
|
||||
try {
|
||||
if (!apiKey) {
|
||||
logger.warn(`⚠️ API ключ Etherscan не предоставлен, пропускаем верификацию DLE`);
|
||||
return { success: false, error: 'API ключ не предоставлен' };
|
||||
}
|
||||
|
||||
if (!params.autoVerifyAfterDeploy) {
|
||||
logger.info(`ℹ️ Автоматическая верификация отключена, пропускаем верификацию DLE`);
|
||||
return { success: false, error: 'Автоматическая верификация отключена' };
|
||||
}
|
||||
|
||||
logger.info(`🔍 Начинаем верификацию DLE контракта по адресу ${contractAddress} в сети ${chainId}`);
|
||||
|
||||
// Retry логика для верификации (до 3 попыток)
|
||||
const maxVerifyAttempts = 3;
|
||||
let verifyAttempts = 0;
|
||||
|
||||
while (verifyAttempts < maxVerifyAttempts) {
|
||||
verifyAttempts++;
|
||||
logger.info(`🔄 Попытка верификации ${verifyAttempts}/${maxVerifyAttempts}`);
|
||||
|
||||
try {
|
||||
// Используем Hardhat verify вместо старого сервиса
|
||||
const { exec } = require('child_process');
|
||||
const { promisify } = require('util');
|
||||
const execAsync = promisify(exec);
|
||||
|
||||
// Определяем имя сети для Hardhat из deploy_params
|
||||
const networkName = getNetworkNameForHardhat(chainId, params);
|
||||
if (!networkName) {
|
||||
logger.warn(`⚠️ Неизвестная сеть ${chainId}, пропускаем верификацию`);
|
||||
return { success: false, error: `Неизвестная сеть ${chainId}` };
|
||||
}
|
||||
|
||||
logger.info(`🔧 Используем Hardhat verify для сети ${networkName}`);
|
||||
|
||||
// Создаем временный файл с аргументами конструктора
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const tempArgsFile = path.join(__dirname, '..', '..', 'temp-constructor-args.js');
|
||||
|
||||
// Формируем аргументы в правильном формате для Hardhat
|
||||
// constructorArgs - это hex строка, нам нужны исходные аргументы
|
||||
// Получаем dleConfig и initializer из параметров
|
||||
const { generateDeploymentArgs } = require('../../utils/constructorArgsGenerator');
|
||||
const { dleConfig, initializer } = generateDeploymentArgs(params);
|
||||
|
||||
// Конвертируем BigInt значения в строки для JSON сериализации
|
||||
const serializableDleConfig = {
|
||||
name: dleConfig.name,
|
||||
symbol: dleConfig.symbol,
|
||||
location: dleConfig.location,
|
||||
coordinates: dleConfig.coordinates,
|
||||
jurisdiction: dleConfig.jurisdiction.toString(),
|
||||
okvedCodes: dleConfig.okvedCodes,
|
||||
kpp: dleConfig.kpp.toString(),
|
||||
quorumPercentage: dleConfig.quorumPercentage.toString(),
|
||||
initialPartners: dleConfig.initialPartners,
|
||||
initialAmounts: dleConfig.initialAmounts.map(amount => amount.toString()),
|
||||
supportedChainIds: dleConfig.supportedChainIds.map(id => id.toString())
|
||||
};
|
||||
|
||||
const argsContent = `module.exports = ${JSON.stringify([serializableDleConfig, initializer], null, 2)};`;
|
||||
fs.writeFileSync(tempArgsFile, argsContent);
|
||||
|
||||
try {
|
||||
// Выполняем Hardhat verify
|
||||
const command = `npx hardhat verify --network ${networkName} --constructor-args ${tempArgsFile} ${contractAddress}`;
|
||||
logger.info(`🔧 Выполняем команду: ${command}`);
|
||||
|
||||
// Устанавливаем переменные окружения для Hardhat
|
||||
const envVars = {
|
||||
...process.env,
|
||||
ETHERSCAN_API_KEY: apiKey,
|
||||
SUPPORTED_CHAIN_IDS: JSON.stringify(params.supported_chain_ids || params.supportedChainIds || []),
|
||||
RPC_URLS: JSON.stringify(params.rpc_urls || params.rpcUrls || {})
|
||||
};
|
||||
|
||||
const { stdout, stderr } = await execAsync(command, {
|
||||
cwd: path.join(__dirname, '..', '..'),
|
||||
env: envVars
|
||||
});
|
||||
|
||||
if (stdout.includes('Successfully verified')) {
|
||||
logger.info(`✅ DLE контракт успешно верифицирован через Hardhat!`);
|
||||
logger.info(`📄 Вывод: ${stdout}`);
|
||||
return { success: true, message: 'Верификация успешна' };
|
||||
} else {
|
||||
// Проверяем, нужно ли повторить попытку
|
||||
if (stderr.includes('does not have bytecode') && verifyAttempts < maxVerifyAttempts) {
|
||||
logger.warn(`⚠️ Контракт еще не проиндексирован, ждем 5 секунд...`);
|
||||
await new Promise(resolve => setTimeout(resolve, 5000));
|
||||
continue;
|
||||
}
|
||||
logger.error(`❌ Ошибка верификации: ${stderr || stdout}`);
|
||||
return { success: false, error: stderr || stdout };
|
||||
}
|
||||
} finally {
|
||||
// Удаляем временный файл
|
||||
if (fs.existsSync(tempArgsFile)) {
|
||||
fs.unlinkSync(tempArgsFile);
|
||||
}
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
// Проверяем, нужно ли повторить попытку
|
||||
if (error.message.includes('does not have bytecode') && verifyAttempts < maxVerifyAttempts) {
|
||||
logger.warn(`⚠️ Контракт еще не проиндексирован, ждем 5 секунд...`);
|
||||
await new Promise(resolve => setTimeout(resolve, 5000));
|
||||
continue;
|
||||
}
|
||||
logger.error(`❌ Ошибка при верификации DLE контракта: ${error.message}`);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
// Если все попытки исчерпаны
|
||||
logger.error(`❌ Верификация не удалась после ${maxVerifyAttempts} попыток`);
|
||||
return { success: false, error: 'Верификация не удалась после всех попыток' };
|
||||
} catch (error) {
|
||||
logger.error(`❌ Критическая ошибка при верификации DLE контракта: ${error.message}`);
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
async function deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, dleInit, params, dleConfig, initializer, etherscanKey) {
|
||||
try {
|
||||
const { ethers } = hre;
|
||||
|
||||
// Используем новый менеджер RPC с retry логикой
|
||||
const { provider, wallet, network } = await createRPCConnection(rpcUrl, pk, {
|
||||
maxRetries: 3,
|
||||
timeout: 30000
|
||||
});
|
||||
|
||||
const net = network;
|
||||
|
||||
// DEBUG: базовая информация по сети
|
||||
try {
|
||||
@@ -250,7 +421,7 @@ async function deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, dleInit
|
||||
if (params.logoURI && params.logoURI !== '') {
|
||||
try {
|
||||
logger.info(`[MULTI_DBG] chainId=${Number(net.chainId)} checking logoURI for existing contract`);
|
||||
const DLE = await hre.ethers.getContractFactory('DLE');
|
||||
const DLE = await hre.ethers.getContractFactory('contracts/DLE.sol:DLE');
|
||||
const dleContract = DLE.attach(predictedAddress);
|
||||
|
||||
const currentLogo = await dleContract.logoURI();
|
||||
@@ -348,7 +519,7 @@ async function deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, dleInit
|
||||
if (params.logoURI && params.logoURI !== '') {
|
||||
try {
|
||||
logger.info(`[MULTI_DBG] chainId=${Number(net.chainId)} initializing logoURI: ${params.logoURI}`);
|
||||
const DLE = await hre.ethers.getContractFactory('DLE');
|
||||
const DLE = await hre.ethers.getContractFactory('contracts/DLE.sol:DLE');
|
||||
const dleContract = DLE.attach(deployedAddress);
|
||||
|
||||
const logoTx = await dleContract.connect(wallet).initializeLogoURI(params.logoURI, feeOverrides);
|
||||
@@ -362,7 +533,94 @@ async function deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, dleInit
|
||||
logger.info(`[MULTI_DBG] chainId=${Number(net.chainId)} no logoURI specified, skipping initialization`);
|
||||
}
|
||||
|
||||
return { address: deployedAddress, chainId: Number(net.chainId) };
|
||||
// Автоматическая верификация DLE контракта после успешного деплоя
|
||||
let verificationResult = { success: false, error: 'skipped' };
|
||||
|
||||
if ((etherscanKey || params.etherscanApiKey) && params.autoVerifyAfterDeploy) {
|
||||
try {
|
||||
logger.info(`🔍 Начинаем автоматическую верификацию DLE контракта...`);
|
||||
logger.info(`[VERIFY_DBG] dleConfig available: ${!!dleConfig}`);
|
||||
logger.info(`[VERIFY_DBG] initializer: ${initializer}`);
|
||||
|
||||
// Кодируем аргументы конструктора в hex
|
||||
// Конструктор DLE: constructor(DLEConfig memory config, address _initializer)
|
||||
const abiCoder = ethers.AbiCoder.defaultAbiCoder();
|
||||
|
||||
// Структура DLEConfig
|
||||
const dleConfigType = 'tuple(string,string,string,string,uint256,string[],uint256,uint256,address[],uint256[],uint256[])';
|
||||
|
||||
// Подготавливаем DLEConfig tuple (все значения уже BigInt из constructorArgsGenerator)
|
||||
const dleConfigTuple = [
|
||||
dleConfig.name,
|
||||
dleConfig.symbol,
|
||||
dleConfig.location,
|
||||
dleConfig.coordinates,
|
||||
dleConfig.jurisdiction, // уже BigInt
|
||||
dleConfig.okvedCodes, // уже массив строк
|
||||
dleConfig.kpp, // уже BigInt
|
||||
dleConfig.quorumPercentage, // уже BigInt
|
||||
dleConfig.initialPartners,
|
||||
dleConfig.initialAmounts, // уже BigInt массив
|
||||
dleConfig.supportedChainIds // уже BigInt массив
|
||||
];
|
||||
|
||||
// Кодируем конструктор: (DLEConfig, address)
|
||||
const constructorArgsHex = abiCoder.encode(
|
||||
[dleConfigType, 'address'],
|
||||
[dleConfigTuple, initializer]
|
||||
).slice(2); // Убираем префикс 0x
|
||||
|
||||
logger.info(`[VERIFY_DBG] Constructor args encoded: ${constructorArgsHex.slice(0, 100)}...`);
|
||||
|
||||
// Ждем 5 секунд перед верификацией для индексации контракта
|
||||
logger.info(`[VERIFY_DBG] Ожидаем 5 секунд для индексации контракта...`);
|
||||
await new Promise(resolve => setTimeout(resolve, 5000));
|
||||
|
||||
logger.info(`[VERIFY_DBG] Calling verifyDLEAfterDeploy...`);
|
||||
verificationResult = await verifyDLEAfterDeploy(
|
||||
Number(network.chainId),
|
||||
deployedAddress,
|
||||
constructorArgsHex,
|
||||
etherscanKey || params.etherscanApiKey,
|
||||
params
|
||||
);
|
||||
logger.info(`[VERIFY_DBG] verifyDLEAfterDeploy completed`);
|
||||
|
||||
if (verificationResult.success) {
|
||||
logger.info(`✅ DLE контракт верифицирован: ${deployedAddress}`);
|
||||
} else {
|
||||
logger.warn(`⚠️ Верификация DLE не удалась: ${verificationResult.error || verificationResult.message}`);
|
||||
}
|
||||
} catch (verificationError) {
|
||||
const errorMsg = verificationError.message || String(verificationError);
|
||||
const errorStack = verificationError.stack || 'No stack trace';
|
||||
logger.error(`❌ Ошибка при верификации DLE: ${errorMsg}`);
|
||||
logger.error(`❌ Стек ошибки верификации: ${errorStack}`);
|
||||
verificationResult = { success: false, error: errorMsg };
|
||||
}
|
||||
} else {
|
||||
if (!(etherscanKey || params.etherscanApiKey)) {
|
||||
logger.info(`ℹ️ API ключ Etherscan не предоставлен, пропускаем верификацию DLE`);
|
||||
} else if (!params.autoVerifyAfterDeploy) {
|
||||
logger.info(`ℹ️ Автоматическая верификация отключена, пропускаем верификацию DLE`);
|
||||
}
|
||||
}
|
||||
|
||||
const finalChainId = Number(network.chainId);
|
||||
logger.info(`[MULTI_DBG] chainId=${finalChainId} Returning deployment result: address=${deployedAddress}`);
|
||||
return {
|
||||
address: deployedAddress,
|
||||
chainId: finalChainId,
|
||||
verification: verificationResult
|
||||
};
|
||||
} catch (error) {
|
||||
const errorMsg = error.message || String(error);
|
||||
const errorStack = error.stack || 'No stack trace';
|
||||
const chainIdStr = network?.chainId ? Number(network.chainId) : 'unknown';
|
||||
logger.error(`[MULTI_DBG] chainId=${chainIdStr} deployment failed: ${errorMsg}`);
|
||||
logger.error(`[MULTI_DBG] chainId=${chainIdStr} error stack: ${errorStack}`);
|
||||
throw error; // Перебрасываем ошибку для обработки в main()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -437,8 +695,15 @@ async function main() {
|
||||
});
|
||||
|
||||
const pk = params.private_key || process.env.PRIVATE_KEY;
|
||||
|
||||
// ИСПРАВЛЕНИЕ: Используем RPC URLs из deployParams, а не из rpcProviderService
|
||||
const networks = params.rpcUrls || params.rpc_urls || [];
|
||||
|
||||
logger.info(`[MULTI_DBG] 📊 RPC URLs из deployParams: ${networks.length} сетей`);
|
||||
networks.forEach((url, i) => {
|
||||
logger.info(`[MULTI_DBG] ${i + 1}. ${url}`);
|
||||
});
|
||||
|
||||
// Устанавливаем API ключи Etherscan для верификации
|
||||
const ApiKeyManager = require('../../utils/apiKeyManager');
|
||||
const etherscanKey = ApiKeyManager.getAndSetEtherscanApiKey(params);
|
||||
@@ -532,12 +797,21 @@ async function main() {
|
||||
throw new Error(`InitCode не найден для chainId: ${chainId}`);
|
||||
}
|
||||
|
||||
const r = await deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, networkInitCode, params);
|
||||
const r = await deployInNetwork(rpcUrl, pk, initCodeHash, targetDLENonce, networkInitCode, params, dleConfig, initializer, etherscanKey);
|
||||
logger.info(`[MULTI_DBG] ✅ Network ${i + 1} (chainId: ${chainId}) deployment SUCCESS: ${r.address}`);
|
||||
return { rpcUrl, chainId, address: r.address, chainId: r.chainId };
|
||||
return {
|
||||
rpcUrl,
|
||||
chainId,
|
||||
address: r.address,
|
||||
success: true,
|
||||
verification: r.verification || { success: false, error: 'unknown' }
|
||||
};
|
||||
} catch (error) {
|
||||
logger.error(`[MULTI_DBG] ❌ Network ${i + 1} deployment FAILED:`, error.message);
|
||||
return { rpcUrl, chainId, error: error.message };
|
||||
const errorMsg = error.message || String(error);
|
||||
const errorStack = error.stack || 'No stack trace';
|
||||
logger.error(`[MULTI_DBG] ❌ Network ${i + 1} (chainId: ${chainId}) deployment FAILED: ${errorMsg}`);
|
||||
logger.error(`[MULTI_DBG] ❌ Network ${i + 1} (chainId: ${chainId}) error stack: ${errorStack}`);
|
||||
return { rpcUrl, chainId, error: errorMsg, success: false };
|
||||
}
|
||||
});
|
||||
|
||||
@@ -554,8 +828,12 @@ async function main() {
|
||||
}
|
||||
});
|
||||
|
||||
// Логируем все результаты для отладки
|
||||
logger.info('[MULTI_DBG] Raw results:', JSON.stringify(results, null, 2));
|
||||
|
||||
// Проверяем, что все адреса одинаковые (критично для детерминированного деплоя)
|
||||
const addresses = results.map(r => r.address).filter(addr => addr);
|
||||
const successfulResults = results.filter(r => r.success === true);
|
||||
const addresses = successfulResults.map(r => r.address).filter(addr => addr);
|
||||
const uniqueAddresses = [...new Set(addresses)];
|
||||
|
||||
logger.info('[MULTI_DBG] All addresses:', addresses);
|
||||
@@ -576,29 +854,19 @@ async function main() {
|
||||
|
||||
logger.info('[MULTI_DBG] SUCCESS: All DLE addresses are identical:', uniqueAddresses[0]);
|
||||
|
||||
// ВЫВОДИМ РЕЗУЛЬТАТ СРАЗУ ПОСЛЕ ДЕПЛОЯ (ПЕРЕД ВЕРИФИКАЦИЕЙ)!
|
||||
console.log('[MULTI_DBG] 🎯 ДОШЛИ ДО ВЫВОДА РЕЗУЛЬТАТА!');
|
||||
const finalResults = results.map((result, index) => ({
|
||||
// Верификация уже выполнена в процессе деплоя
|
||||
const finalResults = results.map((result) => ({
|
||||
...result,
|
||||
verification: 'pending'
|
||||
verification: result.verification || { success: false, error: 'not_attempted' }
|
||||
}));
|
||||
|
||||
// ВЫВОДИМ РЕЗУЛЬТАТ С ИНТЕГРИРОВАННОЙ ВЕРИФИКАЦИЕЙ!
|
||||
console.log('[MULTI_DBG] 🎯 ДОШЛИ ДО ВЫВОДА РЕЗУЛЬТАТА!');
|
||||
console.log('[MULTI_DBG] 📊 finalResults:', JSON.stringify(finalResults, null, 2));
|
||||
console.log('[MULTI_DBG] 🎯 ВЫВОДИМ MULTICHAIN_DEPLOY_RESULT!');
|
||||
console.log('MULTICHAIN_DEPLOY_RESULT', JSON.stringify(finalResults));
|
||||
console.log('[MULTI_DBG] ✅ MULTICHAIN_DEPLOY_RESULT ВЫВЕДЕН!');
|
||||
logger.info('[MULTI_DBG] DLE deployment completed successfully!');
|
||||
|
||||
// Верификация контрактов отключена
|
||||
logger.info('[MULTI_DBG] Contract verification disabled - skipping verification step');
|
||||
|
||||
// Отмечаем все результаты как без верификации
|
||||
const finalResultsWithVerification = results.map((result) => ({
|
||||
...result,
|
||||
verification: 'skipped'
|
||||
}));
|
||||
|
||||
logger.info('[MULTI_DBG] Verification skipped - deployment completed successfully');
|
||||
logger.info('[MULTI_DBG] DLE deployment completed successfully with integrated verification!');
|
||||
}
|
||||
|
||||
console.log('[MULTI_DBG] 🚀 ВЫЗЫВАЕМ MAIN()...');
|
||||
|
||||
@@ -1,600 +0,0 @@
|
||||
/**
|
||||
* Верификация контрактов в Etherscan V2
|
||||
*/
|
||||
|
||||
// const { execSync } = require('child_process'); // Удалено - больше не используем Hardhat verify
|
||||
const DeployParamsService = require('../services/deployParamsService');
|
||||
const deploymentWebSocketService = require('../services/deploymentWebSocketService');
|
||||
const { getSecret } = require('../services/secretStore');
|
||||
|
||||
// Функция для определения Etherscan V2 API URL по chainId
|
||||
function getEtherscanApiUrl(chainId) {
|
||||
// Используем единый Etherscan V2 API для всех сетей
|
||||
return `https://api.etherscan.io/v2/api?chainid=${chainId}`;
|
||||
}
|
||||
|
||||
// Импортируем вспомогательную функцию
|
||||
const { createStandardJsonInput: createStandardJsonInputHelper } = require('../utils/standardJsonInputHelper');
|
||||
|
||||
// Функция для создания стандартного JSON input
|
||||
function createStandardJsonInput() {
|
||||
const path = require('path');
|
||||
const contractPath = path.join(__dirname, '../contracts/DLE.sol');
|
||||
return createStandardJsonInputHelper(contractPath, 'DLE');
|
||||
}
|
||||
|
||||
// Функция для проверки статуса верификации
|
||||
async function checkVerificationStatus(chainId, guid, apiKey) {
|
||||
const apiUrl = getEtherscanApiUrl(chainId);
|
||||
|
||||
const formData = new URLSearchParams({
|
||||
apikey: apiKey,
|
||||
module: 'contract',
|
||||
action: 'checkverifystatus',
|
||||
guid: guid
|
||||
});
|
||||
|
||||
try {
|
||||
const response = await fetch(apiUrl, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/x-www-form-urlencoded',
|
||||
},
|
||||
body: formData
|
||||
});
|
||||
|
||||
const result = await response.json();
|
||||
return result;
|
||||
} catch (error) {
|
||||
console.error('❌ Ошибка при проверке статуса:', error.message);
|
||||
return { status: '0', message: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
// Функция для проверки реального статуса контракта в Etherscan
|
||||
async function checkContractVerificationStatus(chainId, contractAddress, apiKey) {
|
||||
const apiUrl = getEtherscanApiUrl(chainId);
|
||||
|
||||
const formData = new URLSearchParams({
|
||||
apikey: apiKey,
|
||||
module: 'contract',
|
||||
action: 'getsourcecode',
|
||||
address: contractAddress
|
||||
});
|
||||
|
||||
try {
|
||||
const response = await fetch(apiUrl, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/x-www-form-urlencoded',
|
||||
},
|
||||
body: formData
|
||||
});
|
||||
|
||||
const result = await response.json();
|
||||
|
||||
if (result.status === '1' && result.result && result.result[0]) {
|
||||
const contractInfo = result.result[0];
|
||||
const isVerified = contractInfo.SourceCode && contractInfo.SourceCode !== '';
|
||||
|
||||
console.log(`🔍 Статус контракта ${contractAddress}:`, {
|
||||
isVerified: isVerified,
|
||||
contractName: contractInfo.ContractName || 'Unknown',
|
||||
compilerVersion: contractInfo.CompilerVersion || 'Unknown'
|
||||
});
|
||||
|
||||
return { isVerified, contractInfo };
|
||||
} else {
|
||||
console.log('❌ Не удалось получить информацию о контракте:', result.message);
|
||||
return { isVerified: false, error: result.message };
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('❌ Ошибка при проверке статуса контракта:', error.message);
|
||||
return { isVerified: false, error: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
// Функция для верификации контракта в Etherscan V2
|
||||
async function verifyContractInEtherscan(chainId, contractAddress, constructorArgsHex, apiKey) {
|
||||
const apiUrl = getEtherscanApiUrl(chainId);
|
||||
const standardJsonInput = createStandardJsonInput();
|
||||
|
||||
console.log(`🔍 Верификация контракта ${contractAddress} в Etherscan V2 (chainId: ${chainId})`);
|
||||
console.log(`📡 API URL: ${apiUrl}`);
|
||||
|
||||
const formData = new URLSearchParams({
|
||||
apikey: apiKey,
|
||||
module: 'contract',
|
||||
action: 'verifysourcecode',
|
||||
contractaddress: contractAddress,
|
||||
codeformat: 'solidity-standard-json-input',
|
||||
contractname: 'DLE.sol:DLE',
|
||||
sourceCode: JSON.stringify(standardJsonInput),
|
||||
compilerversion: 'v0.8.20+commit.a1b79de6',
|
||||
optimizationUsed: '1',
|
||||
runs: '0',
|
||||
constructorArguements: constructorArgsHex
|
||||
});
|
||||
|
||||
try {
|
||||
const response = await fetch(apiUrl, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/x-www-form-urlencoded',
|
||||
},
|
||||
body: formData
|
||||
});
|
||||
|
||||
const result = await response.json();
|
||||
console.log('📥 Ответ от Etherscan V2:', result);
|
||||
|
||||
if (result.status === '1') {
|
||||
console.log('✅ Верификация отправлена в Etherscan V2!');
|
||||
console.log(`📋 GUID: ${result.result}`);
|
||||
|
||||
// Ждем и проверяем статус верификации с повторными попытками
|
||||
console.log('⏳ Ждем 15 секунд перед проверкой статуса...');
|
||||
await new Promise(resolve => setTimeout(resolve, 15000));
|
||||
|
||||
// Проверяем статус с повторными попытками (до 3 раз)
|
||||
let statusResult;
|
||||
let attempts = 0;
|
||||
const maxAttempts = 3;
|
||||
|
||||
do {
|
||||
attempts++;
|
||||
console.log(`📊 Проверка статуса верификации (попытка ${attempts}/${maxAttempts})...`);
|
||||
statusResult = await checkVerificationStatus(chainId, result.result, apiKey);
|
||||
console.log('📊 Статус верификации:', statusResult);
|
||||
|
||||
if (statusResult.status === '1') {
|
||||
console.log('🎉 Верификация успешна!');
|
||||
return { success: true, guid: result.result, message: 'Верифицировано в Etherscan V2' };
|
||||
} else if (statusResult.status === '0' && statusResult.result.includes('Pending')) {
|
||||
console.log('⏳ Верификация в очереди, проверяем реальный статус контракта...');
|
||||
|
||||
// Проверяем реальный статус контракта в Etherscan
|
||||
const contractStatus = await checkContractVerificationStatus(chainId, contractAddress, apiKey);
|
||||
if (contractStatus.isVerified) {
|
||||
console.log('✅ Контракт уже верифицирован в Etherscan!');
|
||||
return { success: true, guid: result.result, message: 'Контракт верифицирован' };
|
||||
} else {
|
||||
console.log('⏳ Контракт еще не верифицирован, ожидаем завершения...');
|
||||
if (attempts < maxAttempts) {
|
||||
console.log(`⏳ Ждем еще 10 секунд перед следующей попыткой...`);
|
||||
await new Promise(resolve => setTimeout(resolve, 10000));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
console.log('❌ Верификация не удалась:', statusResult.result);
|
||||
return { success: false, error: statusResult.result };
|
||||
}
|
||||
} while (attempts < maxAttempts && statusResult.status === '0' && statusResult.result.includes('Pending'));
|
||||
|
||||
// Если все попытки исчерпаны
|
||||
if (attempts >= maxAttempts) {
|
||||
console.log('⏳ Максимальное количество попыток достигнуто, верификация может быть в процессе...');
|
||||
return { success: false, error: 'Ожидание верификации', guid: result.result };
|
||||
}
|
||||
} else {
|
||||
console.log('❌ Ошибка отправки верификации в Etherscan V2:', result.message);
|
||||
|
||||
// Проверяем, не верифицирован ли уже контракт
|
||||
if (result.message && result.message.includes('already verified')) {
|
||||
console.log('✅ Контракт уже верифицирован');
|
||||
return { success: true, message: 'Контракт уже верифицирован' };
|
||||
}
|
||||
|
||||
return { success: false, error: result.message };
|
||||
}
|
||||
} catch (error) {
|
||||
console.error('❌ Ошибка при отправке запроса в Etherscan V2:', error.message);
|
||||
|
||||
// Проверяем, не является ли это ошибкой сети
|
||||
if (error.message.includes('fetch') || error.message.includes('network')) {
|
||||
console.log('⚠️ Ошибка сети, верификация может быть в процессе...');
|
||||
return { success: false, error: 'Network error - verification may be in progress' };
|
||||
}
|
||||
|
||||
return { success: false, error: error.message };
|
||||
}
|
||||
}
|
||||
|
||||
async function verifyWithHardhatV2(params = null, deployedNetworks = null) {
|
||||
console.log('🚀 Запуск верификации контрактов...');
|
||||
|
||||
try {
|
||||
// Если параметры не переданы, получаем их из базы данных
|
||||
if (!params) {
|
||||
const DeployParamsService = require('../services/deployParamsService');
|
||||
const deployParamsService = new DeployParamsService();
|
||||
const latestParams = await deployParamsService.getLatestDeployParams(1);
|
||||
|
||||
if (latestParams.length === 0) {
|
||||
throw new Error('Нет параметров деплоя в базе данных');
|
||||
}
|
||||
|
||||
params = latestParams[0];
|
||||
}
|
||||
|
||||
// Проверяем API ключ в параметрах или переменной окружения
|
||||
const etherscanApiKey = params.etherscan_api_key || process.env.ETHERSCAN_API_KEY;
|
||||
if (!etherscanApiKey) {
|
||||
throw new Error('Etherscan API ключ не найден в параметрах или переменной окружения');
|
||||
}
|
||||
|
||||
// Устанавливаем API ключ в переменную окружения для использования в коде
|
||||
process.env.ETHERSCAN_API_KEY = etherscanApiKey;
|
||||
|
||||
console.log('📋 Параметры деплоя:', {
|
||||
deploymentId: params.deployment_id,
|
||||
name: params.name,
|
||||
symbol: params.symbol
|
||||
});
|
||||
|
||||
// Получаем адреса контрактов
|
||||
let networks = [];
|
||||
|
||||
if (deployedNetworks && Array.isArray(deployedNetworks)) {
|
||||
// Используем переданные данные о сетях
|
||||
networks = deployedNetworks;
|
||||
console.log('📊 Используем переданные данные о развернутых сетях');
|
||||
} else if (params.deployedNetworks && Array.isArray(params.deployedNetworks)) {
|
||||
networks = params.deployedNetworks;
|
||||
} else if (params.dle_address && params.supportedChainIds) {
|
||||
// Создаем deployedNetworks на основе dle_address и supportedChainIds
|
||||
networks = params.supportedChainIds.map(chainId => ({
|
||||
chainId: chainId,
|
||||
address: params.dle_address
|
||||
}));
|
||||
console.log('📊 Создали deployedNetworks на основе dle_address и supportedChainIds');
|
||||
} else {
|
||||
throw new Error('Нет данных о развернутых сетях или адресе контракта');
|
||||
}
|
||||
console.log(`🌐 Найдено ${networks.length} развернутых сетей`);
|
||||
|
||||
// Получаем маппинг chainId на названия сетей из параметров деплоя
|
||||
const networkMap = {};
|
||||
if (params.supportedChainIds && params.supportedChainIds.length > 0) {
|
||||
// Создаем маппинг только для поддерживаемых сетей
|
||||
for (const chainId of params.supportedChainIds) {
|
||||
switch (chainId) {
|
||||
case 1: networkMap[chainId] = 'mainnet'; break;
|
||||
case 11155111: networkMap[chainId] = 'sepolia'; break;
|
||||
case 17000: networkMap[chainId] = 'holesky'; break;
|
||||
case 137: networkMap[chainId] = 'polygon'; break;
|
||||
case 42161: networkMap[chainId] = 'arbitrumOne'; break;
|
||||
case 421614: networkMap[chainId] = 'arbitrumSepolia'; break;
|
||||
case 56: networkMap[chainId] = 'bsc'; break;
|
||||
case 8453: networkMap[chainId] = 'base'; break;
|
||||
case 84532: networkMap[chainId] = 'baseSepolia'; break;
|
||||
default: networkMap[chainId] = `chain-${chainId}`; break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Fallback для совместимости
|
||||
networkMap[11155111] = 'sepolia';
|
||||
networkMap[17000] = 'holesky';
|
||||
networkMap[421614] = 'arbitrumSepolia';
|
||||
networkMap[84532] = 'baseSepolia';
|
||||
}
|
||||
|
||||
// Используем централизованный генератор параметров конструктора
|
||||
const { generateVerificationArgs } = require('../utils/constructorArgsGenerator');
|
||||
const constructorArgs = generateVerificationArgs(params);
|
||||
|
||||
console.log('📊 Аргументы конструктора подготовлены');
|
||||
|
||||
// Верифицируем контракт в каждой сети
|
||||
const verificationResults = [];
|
||||
|
||||
for (const network of networks) {
|
||||
const { chainId, address } = network;
|
||||
|
||||
if (!address || address === '0x0000000000000000000000000000000000000000') {
|
||||
console.log(`⚠️ Пропускаем сеть ${chainId} - нет адреса контракта`);
|
||||
verificationResults.push({
|
||||
success: false,
|
||||
network: chainId,
|
||||
error: 'No contract address'
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
const networkName = networkMap[chainId];
|
||||
if (!networkName) {
|
||||
console.log(`⚠️ Неизвестная сеть ${chainId}, пропускаем верификацию`);
|
||||
verificationResults.push({
|
||||
success: false,
|
||||
network: chainId,
|
||||
error: 'Unknown network'
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
console.log(`\n🔍 Верификация в сети ${networkName} (chainId: ${chainId})`);
|
||||
console.log(`📍 Адрес: ${address}`);
|
||||
|
||||
// Добавляем задержку между верификациями
|
||||
if (verificationResults.length > 0) {
|
||||
console.log('⏳ Ждем 5 секунд перед следующей верификацией...');
|
||||
await new Promise(resolve => setTimeout(resolve, 5000));
|
||||
}
|
||||
|
||||
// Получаем API ключ Etherscan
|
||||
const etherscanApiKey = process.env.ETHERSCAN_API_KEY;
|
||||
if (!etherscanApiKey) {
|
||||
console.log('❌ API ключ Etherscan не найден, пропускаем верификацию в Etherscan');
|
||||
verificationResults.push({
|
||||
success: false,
|
||||
network: networkName,
|
||||
chainId: chainId,
|
||||
error: 'No Etherscan API key'
|
||||
});
|
||||
continue;
|
||||
}
|
||||
|
||||
// Кодируем аргументы конструктора в hex
|
||||
const { ethers } = require('ethers');
|
||||
const abiCoder = ethers.AbiCoder.defaultAbiCoder();
|
||||
|
||||
// Используем централизованный генератор параметров конструктора
|
||||
const { generateDeploymentArgs } = require('../utils/constructorArgsGenerator');
|
||||
const { dleConfig, initializer } = generateDeploymentArgs(params);
|
||||
|
||||
const encodedArgs = abiCoder.encode(
|
||||
[
|
||||
'tuple(string name, string symbol, string location, string coordinates, uint256 jurisdiction, string[] okvedCodes, uint256 kpp, uint256 quorumPercentage, address[] initialPartners, uint256[] initialAmounts, uint256[] supportedChainIds)',
|
||||
'address'
|
||||
],
|
||||
[
|
||||
dleConfig,
|
||||
initializer
|
||||
]
|
||||
);
|
||||
|
||||
const constructorArgsHex = encodedArgs.slice(2); // Убираем 0x
|
||||
|
||||
// Верификация в Etherscan
|
||||
console.log('🌐 Верификация в Etherscan...');
|
||||
const etherscanResult = await verifyContractInEtherscan(chainId, address, constructorArgsHex, etherscanApiKey);
|
||||
|
||||
if (etherscanResult.success) {
|
||||
console.log('✅ Верификация в Etherscan успешна!');
|
||||
verificationResults.push({
|
||||
success: true,
|
||||
network: networkName,
|
||||
chainId: chainId,
|
||||
etherscan: true,
|
||||
message: etherscanResult.message
|
||||
});
|
||||
} else {
|
||||
console.log('❌ Ошибка верификации в Etherscan:', etherscanResult.error);
|
||||
verificationResults.push({
|
||||
success: false,
|
||||
network: networkName,
|
||||
chainId: chainId,
|
||||
error: etherscanResult.error
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Выводим итоговые результаты
|
||||
console.log('\n📊 Итоговые результаты верификации:');
|
||||
const successful = verificationResults.filter(r => r.success).length;
|
||||
const failed = verificationResults.filter(r => !r.success).length;
|
||||
const etherscanVerified = verificationResults.filter(r => r.etherscan).length;
|
||||
|
||||
console.log(`✅ Успешно верифицировано: ${successful}`);
|
||||
console.log(`🌐 В Etherscan: ${etherscanVerified}`);
|
||||
console.log(`❌ Ошибки: ${failed}`);
|
||||
|
||||
verificationResults.forEach(result => {
|
||||
const status = result.success ? '✅' : '❌';
|
||||
|
||||
const message = result.success
|
||||
? (result.message || 'OK')
|
||||
: result.error?.substring(0, 100) + '...';
|
||||
|
||||
console.log(`${status} ${result.network} (${result.chainId}): ${message}`);
|
||||
});
|
||||
|
||||
console.log('\n🎉 Верификация завершена!');
|
||||
|
||||
} catch (error) {
|
||||
console.error('💥 Ошибка верификации:', error.message);
|
||||
console.error(error.stack);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// Запускаем верификацию если скрипт вызван напрямую
|
||||
if (require.main === module) {
|
||||
// Проверяем аргументы командной строки
|
||||
const args = process.argv.slice(2);
|
||||
|
||||
if (args.includes('--modules')) {
|
||||
// Верификация модулей
|
||||
verifyModules()
|
||||
.then(() => {
|
||||
console.log('\n🏁 Верификация модулей завершена');
|
||||
process.exit(0);
|
||||
})
|
||||
.catch((error) => {
|
||||
console.error('💥 Верификация модулей завершилась с ошибкой:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
} else {
|
||||
// Верификация основного DLE контракта
|
||||
verifyWithHardhatV2()
|
||||
.then(() => {
|
||||
console.log('\n🏁 Скрипт завершен');
|
||||
process.exit(0);
|
||||
})
|
||||
.catch((error) => {
|
||||
console.error('💥 Скрипт завершился с ошибкой:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Функция для верификации модулей
|
||||
async function verifyModules() {
|
||||
console.log('🚀 Запуск верификации модулей...');
|
||||
|
||||
try {
|
||||
// Загружаем параметры из базы данных
|
||||
const deployParamsService = new DeployParamsService();
|
||||
const paramsArray = await deployParamsService.getLatestDeployParams(1);
|
||||
|
||||
if (paramsArray.length === 0) {
|
||||
throw new Error('Нет параметров деплоя в базе данных');
|
||||
}
|
||||
|
||||
const params = paramsArray[0];
|
||||
const dleAddress = params.dle_address;
|
||||
|
||||
if (!dleAddress) {
|
||||
throw new Error('Адрес DLE не найден в параметрах');
|
||||
}
|
||||
|
||||
// Уведомляем WebSocket клиентов о начале верификации
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'info', 'Начало верификации модулей');
|
||||
|
||||
console.log('📋 Параметры верификации модулей:', {
|
||||
dleAddress: dleAddress,
|
||||
name: params.name,
|
||||
symbol: params.symbol
|
||||
});
|
||||
|
||||
// Читаем файлы модулей
|
||||
const fs = require('fs');
|
||||
const path = require('path');
|
||||
const modulesDir = path.join(__dirname, 'contracts-data/modules');
|
||||
|
||||
if (!fs.existsSync(modulesDir)) {
|
||||
console.log('📁 Папка модулей не найдена:', modulesDir);
|
||||
return;
|
||||
}
|
||||
|
||||
const moduleFiles = fs.readdirSync(modulesDir).filter(file => file.endsWith('.json'));
|
||||
console.log(`📁 Найдено ${moduleFiles.length} файлов модулей`);
|
||||
|
||||
// Конфигурация модулей для верификации
|
||||
const MODULE_CONFIGS = {
|
||||
treasury: {
|
||||
contractName: 'TreasuryModule',
|
||||
constructorArgs: (dleAddress, chainId, walletAddress) => [
|
||||
dleAddress,
|
||||
chainId,
|
||||
walletAddress
|
||||
]
|
||||
},
|
||||
timelock: {
|
||||
contractName: 'TimelockModule',
|
||||
constructorArgs: (dleAddress, chainId, walletAddress) => [
|
||||
dleAddress
|
||||
]
|
||||
},
|
||||
reader: {
|
||||
contractName: 'DLEReader',
|
||||
constructorArgs: (dleAddress, chainId, walletAddress) => [
|
||||
dleAddress
|
||||
]
|
||||
},
|
||||
hierarchicalVoting: {
|
||||
contractName: 'HierarchicalVotingModule',
|
||||
constructorArgs: (dleAddress, chainId, walletAddress) => [
|
||||
dleAddress
|
||||
]
|
||||
}
|
||||
};
|
||||
|
||||
// Получаем маппинг chainId на названия сетей из параметров деплоя
|
||||
const networkMap = {};
|
||||
if (params.supportedChainIds && params.supportedChainIds.length > 0) {
|
||||
// Создаем маппинг только для поддерживаемых сетей
|
||||
for (const chainId of params.supportedChainIds) {
|
||||
switch (chainId) {
|
||||
case 11155111: networkMap[chainId] = 'sepolia'; break;
|
||||
case 17000: networkMap[chainId] = 'holesky'; break;
|
||||
case 421614: networkMap[chainId] = 'arbitrumSepolia'; break;
|
||||
case 84532: networkMap[chainId] = 'baseSepolia'; break;
|
||||
default: networkMap[chainId] = `chain-${chainId}`; break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Fallback для совместимости
|
||||
networkMap[11155111] = 'sepolia';
|
||||
networkMap[17000] = 'holesky';
|
||||
networkMap[421614] = 'arbitrumSepolia';
|
||||
networkMap[84532] = 'baseSepolia';
|
||||
}
|
||||
|
||||
// Верифицируем каждый модуль
|
||||
for (const file of moduleFiles) {
|
||||
const filePath = path.join(modulesDir, file);
|
||||
const moduleData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
|
||||
|
||||
const moduleConfig = MODULE_CONFIGS[moduleData.moduleType];
|
||||
if (!moduleConfig) {
|
||||
console.log(`⚠️ Неизвестный тип модуля: ${moduleData.moduleType}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
console.log(`🔍 Верификация модуля: ${moduleData.moduleType}`);
|
||||
|
||||
// Верифицируем в каждой сети
|
||||
for (const network of moduleData.networks) {
|
||||
if (!network.success || !network.address) {
|
||||
console.log(`⚠️ Пропускаем сеть ${network.chainId} - модуль не задеплоен`);
|
||||
continue;
|
||||
}
|
||||
|
||||
const networkName = networkMap[network.chainId];
|
||||
if (!networkName) {
|
||||
console.log(`⚠️ Неизвестная сеть: ${network.chainId}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
try {
|
||||
console.log(`🔍 Верификация ${moduleData.moduleType} в сети ${networkName} (${network.chainId})`);
|
||||
|
||||
// Подготавливаем аргументы конструктора
|
||||
const constructorArgs = moduleConfig.constructorArgs(
|
||||
dleAddress,
|
||||
network.chainId,
|
||||
params.initializer || "0x0000000000000000000000000000000000000000"
|
||||
);
|
||||
|
||||
// Создаем временный файл с аргументами
|
||||
const argsFile = path.join(__dirname, `temp-args-${Date.now()}.json`);
|
||||
fs.writeFileSync(argsFile, JSON.stringify(constructorArgs, null, 2));
|
||||
|
||||
// Верификация модулей через Etherscan V2 API (пока не реализовано)
|
||||
console.log(`⚠️ Верификация модулей через Etherscan V2 API пока не реализована для ${moduleData.moduleType} в ${networkName}`);
|
||||
|
||||
// Удаляем временный файл
|
||||
if (fs.existsSync(argsFile)) {
|
||||
fs.unlinkSync(argsFile);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error(`❌ Ошибка при верификации ${moduleData.moduleType} в сети ${network.chainId}:`, error.message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
console.log('\n🏁 Верификация модулей завершена');
|
||||
|
||||
// Уведомляем WebSocket клиентов о завершении верификации
|
||||
deploymentWebSocketService.addDeploymentLog(dleAddress, 'success', 'Верификация всех модулей завершена');
|
||||
deploymentWebSocketService.notifyModulesUpdated(dleAddress);
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ Ошибка при верификации модулей:', error.message);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { verifyWithHardhatV2, verifyContracts: verifyWithHardhatV2, verifyModules };
|
||||
Reference in New Issue
Block a user