feat: offline signing using ledger [AXE-1805]

evm/.example.hardhat.config.js

@@ -2,7 +2,7 @@
 require('@nomicfoundation/hardhat-toolbox');
 
 const env = process.env.ENV || 'testnet';
-const { importNetworks, readJSON } = require('@axelar-network/axelar-contract-deployments');
+const { importNetworks, readJSON } = require('@axelar-network/axelar-chains-config');
 const chains = require(`@axelar-network/axelar-chains-config/info/${env}.json`);
 const keys = readJSON(`${__dirname}/keys.json`);
 const { networks, etherscan } = importNetworks(chains, keys);

evm/broadcast-transactions.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const chalk = require('chalk');
+const { Command, Option } = require('commander');
+const { ethers } = require('hardhat');
+const {
+    providers: { getDefaultProvider },
+} = ethers;
+const readlineSync = require('readline-sync');
+
+const { printError, printInfo, printWarn, mainProcessor } = require('./utils');
+const { sendTransaction, getSignedTx, storeSignedTx } = require('./offline-sign-utils');
+
+async function processCommand(_, chain, options) {
+    const { filePath, rpc } = options;
+
+    const provider = getDefaultProvider(rpc || chain.rpc);
+
+    if (!options.yes) {
+        const anwser = readlineSync.question(
+            `Proceed with the broadcasting of all pending signed transactions for file ${chalk.green(
+                options.filePath,
+            )} on chain ${chalk.green(chain.name)} ${chalk.green('(y/n)')} `,
+        );
+        if (anwser !== 'y') return;
+    }
+
+    if (!filePath) {
+        throw new Error('FilePath is not provided in user info');
+    }
+
+    const transaction = await getSignedTx(filePath);
+
+    if (transaction.status === 'PENDING') {
+        printInfo('Broadcasting transaction', JSON.stringify(transaction.unsignedTx, null, 2));
+
+        // Send the signed transaction
+        try {
+            const { response } = await sendTransaction(transaction.signedTx, provider, chain.confirmations);
+            transaction.status = 'SUCCESS';
+            transaction.hash = response.hash;
+            printInfo('Transaction executed successfully', response.hash);
+        } catch (error) {
+            transaction.status = 'FAILED';
+            printError('Error broadcasting tx', error);
+        }
+
+        storeSignedTx(filePath, transaction);
+    } else {
+        printWarn('Skipping broadcast, transaction status is', transaction.status);
+    }
+}
+
+async function main(options) {
+    await mainProcessor(options, processCommand);
+}
+
+const program = new Command();
+
+program.name('broadcast-transactions').description('Broadcast all the pending signed transactions of the signer');
+
+program.addOption(new Option('--filePath <filePath>', 'The file where the signed tx are stored').makeOptionMandatory(true));
+program.addOption(
+    new Option('-e, --env <env>', 'environment')
+        .choices(['local', 'devnet', 'stagenet', 'testnet', 'mainnet'])
+        .default('testnet')
+        .makeOptionMandatory(true)
+        .env('ENV'),
+);
+program.addOption(new Option('-n, --chainName <chainName>', 'chain names').makeOptionMandatory(true));
+program.addOption(new Option('-r, --rpc <rpc>', 'The chain rpc'));
+program.addOption(new Option('-y, --yes', 'skip prompts'));
+
+program.action((options) => {
+    main(options);
+});
+
+program.parse();

evm/check-wallet-balance.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { Command, Option } = require('commander');
+const { ethers } = require('hardhat');
+const { getDefaultProvider, BigNumber } = ethers;
+
+const { printError, mainProcessor } = require('./utils');
+const { getNonceFileData } = require('./offline-sign-utils');
+
+async function processCommand(_, chain, options) {
+    const { rpc } = options;
+    let { addresses } = options;
+
+    const chainName = chain.name.toLowerCase();
+    const provider = getDefaultProvider(rpc || chain.rpc);
+    const staticGasOptions = chain.staticGasOptions;
+
+    if (!staticGasOptions) {
+        printError('Could not find staticGasOptions for chain', chain.name);
+        return;
+    }
+
+    const gasLimit = BigNumber.from(staticGasOptions.gasLimit);
+    const gasPrice = BigNumber.from(staticGasOptions.gasPrice);
+    const minRequiredBalance = gasLimit * gasPrice;
+    const nonceData = getNonceFileData();
+    const nonces = nonceData[options.env][chainName];
+
+    if (addresses) {
+        addresses = JSON.parse(addresses);
+    } else {
+        addresses = Object.entries(nonces);
+    }
+
+    for (const address of addresses) {
+        const balance = await provider.getBalance(address);
+
+        if (balance < minRequiredBalance) {
+            printError('Minimum required Balance is', `${minRequiredBalance / 1e18}`);
+            printError(`Wallet Balance for address ${address} is`, `${balance / 1e18}`);
+        }
+    }
+}
+
+async function main(options) {
+    await mainProcessor(options, processCommand);
+}
+
+const program = new Command();
+
+program.name('check-wallet-balance').description('Before offline signing checks if each signer has minimum required wallet balance');
+
+program.addOption(
+    new Option('-e, --env <env>', 'environment')
+        .choices(['local', 'devnet', 'stagenet', 'testnet', 'mainnet'])
+        .default('testnet')
+        .makeOptionMandatory(true)
+        .env('ENV'),
+);
+program.addOption(new Option('-n, --chainNames <chainNames>', 'chain names').makeOptionMandatory(true));
+program.addOption(new Option('-r, --rpc <rpc>', 'The rpc url for creating a provider to fetch gasOptions'));
+program.addOption(new Option('--addresses <addresses>', 'The Array of addresses for which the balance to check').env('ADDRESSES'));
+
+program.action((options) => {
+    main(options);
+});
+
+program.parse();

evm/deploy-const-address-deployer.js

@@ -3,7 +3,7 @@
 require('dotenv').config();
 
 const { ethers } = require('hardhat');
-const { Wallet, getDefaultProvider, ContractFactory } = require('ethers');
+const { Wallet, getDefaultProvider, ContractFactory } = ethers;
 const readlineSync = require('readline-sync');
 const { Command, Option } = require('commander');
 const chalk = require('chalk');

evm/deploy-contract.js

@@ -2,11 +2,12 @@
 
 require('dotenv').config();
 
+const { ethers } = require('hardhat');
 const {
     Wallet,
     getDefaultProvider,
     utils: { isAddress },
-} = require('ethers');
+} = ethers;
 const readlineSync = require('readline-sync');
 const { Command, Option } = require('commander');
 const chalk = require('chalk');

evm/deploy-gateway-v4.3.x.js

@@ -13,6 +13,8 @@ const {
     saveConfig,
     loadConfig,
     printWalletInfo,
+    isAddressArray,
+    isNumber,
 } = require('./utils');
 const { ethers } = require('hardhat');
 const {
@@ -26,8 +28,8 @@ const { Command, Option } = require('commander');
 const chalk = require('chalk');
 
 async function getAuthParams(config, chain) {
-    const { addresses, weights, threshold } = await getEVMAddresses(config, chain);
-    printObj(JSON.stringify({ addresses, weights, threshold }));
+    const { addresses, weights, threshold, keyID } = await getEVMAddresses(config, chain);
+    printObj(JSON.stringify({ status: 'latest', keyID, addresses, weights, threshold }));
     const paramsAuth = [defaultAbiCoder.encode(['address[]', 'uint256[]', 'uint256'], [addresses, weights, threshold])];
     return paramsAuth;
 }
@@ -63,7 +65,7 @@ async function deploy(config, options) {
     });
     printInfo('Predicted proxy address', proxyAddress);
 
-    const gasOptions = contractConfig.gasOptions || chain.gasOptions || {};
+    const gasOptions = contractConfig.gasOptions || chain.gasOptions || { gasLimit: 6e6 };
     printInfo('Gas override', JSON.stringify(gasOptions, null, 2));
     printInfo('Is verification enabled?', verify ? 'y' : 'n');
     printInfo('Skip existing contracts?', skipExisting ? 'y' : 'n');
@@ -73,6 +75,16 @@ async function deploy(config, options) {
     const tokenDeployerFactory = await getContractFactory('TokenDeployer', wallet);
     const gatewayProxyFactory = await getContractFactory('AxelarGatewayProxy', wallet);
 
+    if (!adminAddresses || !isAddressArray(JSON.parse(adminAddresses))) {
+        printError('Invalid admin addresses', `${adminAddresses}`);
+        return;
+    }
+
+    if (!adminThreshold || !isNumber(parseInt(adminThreshold))) {
+        printError('Invalid admin threshold', `${adminThreshold}`);
+        return;
+    }
+
     let gateway;
     let auth;
     let tokenDeployer;
@@ -219,6 +231,7 @@ async function deploy(config, options) {
 
     contractConfig.address = gateway.address;
     contractConfig.implementation = implementation.address;
+    contractConfig.implementationCodehash = implementationCodehash;
     contractConfig.authModule = auth.address;
     contractConfig.tokenDeployer = tokenDeployer.address;