chore: enforced the funds before contract deployment

Ticket: WIN-7265

Author: yogeshwar-bitgo

.github/workflows/update_transfer_gas_limit.yml

@@ -15,6 +15,70 @@ export const logger = {
   step: (msg: string) => console.log(`\n--- ${msg} ---`)
 };
 
+/**
+ * Checks if the deployer has sufficient balance for the deployment.
+ * Requires 1.5x the estimated gas cost to provide a safety buffer.
+ */
+export async function checkSufficientBalance(
+  deployerAddress: string,
+  estimatedGasCost: bigint,
+  contractName: string = 'contract'
+): Promise<void> {
+  const balance = await ethers.provider.getBalance(deployerAddress);
+  const requiredAmount = (estimatedGasCost * 150n) / 100n; // 1.5x buffer
+  
+  logger.info(`💰 Balance check for ${contractName} deployment:`);
+  logger.info(`  Deployer balance: ${ethers.formatEther(balance)} ETH`);
+  logger.info(`  Estimated gas cost: ${ethers.formatEther(estimatedGasCost)} ETH`);
+  logger.info(`  Required (1.5x buffer): ${ethers.formatEther(requiredAmount)} ETH`);
+  
+  if (balance < requiredAmount) {
+    const shortfall = requiredAmount - balance;
+    logger.error(`Insufficient funds for ${contractName} deployment!`);
+    logger.error(`  Shortfall: ${ethers.formatEther(shortfall)} ETH`);
+    logger.error(`  Please fund the deployer account: ${deployerAddress}`);
+    throw new Error(`Insufficient funds: need ${ethers.formatEther(requiredAmount)} ETH, have ${ethers.formatEther(balance)} ETH`);
+  }
+  
+  logger.success(`✅ Sufficient balance confirmed for ${contractName} deployment`);
+}
+
+/**
+ * Checks balance before individual contract deployment.
+ * Estimates gas for a typical contract deployment transaction.
+ */
+export async function checkIndividualContractBalance(
+  deployerAddress: string,
+  contractName: string,
+  gasOverrides?: any
+): Promise<void> {
+  try {
+    // Get current fee data
+    const feeData = await ethers.provider.getFeeData();
+    
+    // Estimate typical contract deployment gas (fallback if we can't estimate precisely)
+    const estimatedGas = 500000n; // 500k gas - reasonable estimate for contract deployment
+    
+    // Calculate gas price
+    let gasPrice: bigint;
+    if (gasOverrides?.gasPrice) {
+      gasPrice = gasOverrides.gasPrice;
+    } else if (gasOverrides?.maxFeePerGas) {
+      gasPrice = gasOverrides.maxFeePerGas;
+    } else {
+      gasPrice = feeData.gasPrice || 1_000_000_000n; // 1 gwei fallback
+    }
+    
+    const estimatedCost = estimatedGas * gasPrice;
+    
+    // Check balance with 1.5x buffer
+    await checkSufficientBalance(deployerAddress, estimatedCost, contractName);
+  } catch (error) {
+    logger.warn(`⚠️ Could not perform precise balance check for ${contractName}: ${(error as Error).message}`);
+    logger.info(`🔄 Proceeding with deployment - will fail fast if insufficient funds`);
+  }
+}
+
 export type DeploymentAddresses = {
   walletImplementation?: string;
   walletFactory?: string;
@@ -31,7 +95,8 @@ export async function deployIfNeededAtNonce(
   expectedNonce: number,
   deployerAddress: string,
   contractName: string,
-  deployFn: () => Promise<string>
+  deployFn: () => Promise<string>,
+  gasOverrides?: any
 ): Promise<string> {
   const predictedAddress = getCreateAddress({
     from: deployerAddress,
@@ -83,12 +148,15 @@ export async function deployIfNeededAtNonce(
     throw new Error(errorMsg);
   }
 
-  // 5. Deploy
+  // 5. Balance check before deployment
+  await checkIndividualContractBalance(deployerAddress, contractName, gasOverrides);
+
+  // 6. Deploy
   logger.info(`🚀 Deploying ${contractName} at nonce ${expectedNonce}...`);
   return await deployFn();
 }
 
-async function isContractDeployed(address: string) {
+export async function isContractDeployed(address: string) {
   const code = await ethers.provider.getCode(address);
   return code && code !== '0x';
 }

deployUtils.ts

@@ -5,7 +5,9 @@ import {
   waitAndVerify,
   loadOutput,
   saveOutput,
-  DeploymentAddresses
+  DeploymentAddresses,
+  checkSufficientBalance,
+  isContractDeployed
 } from '../deployUtils';
 import { setupBigBlocksForV4Deployment } from './enableBigBlocks';
 import { isBigBlocksSupported } from '../config/bigBlocksConfig';
@@ -39,6 +41,69 @@ async function main() {
     `🚀 Deployer: ${deployerAddress} (nonce: ${currentNonce}) on chain ${chainId}`
   );
 
+  // Pre-deployment balance check - estimate total cost for all contracts
+  console.log('\n--- Checking deployer balance ---');
+  
+  // Estimate gas costs for all potential deployments
+  let totalEstimatedCost = 0n;
+  
+  // Only estimate if we need to deploy (not already deployed)
+  if (!output.walletImplementation || !(await isContractDeployed(output.walletImplementation))) {
+    const WalletSimple = await ethers.getContractFactory(chainConfig.walletImplementationContractName);
+    const walletGas = await deployer.estimateGas({
+      ...await WalletSimple.getDeployTransaction(...[], gasOverrides),
+      from: deployerAddress
+    });
+    totalEstimatedCost += walletGas;
+  }
+  
+  if (!output.walletFactory || !(await isContractDeployed(output.walletFactory))) {
+    const WalletFactory = await ethers.getContractFactory(chainConfig.walletFactoryContractName);
+    const factoryGas = await deployer.estimateGas({
+      ...await WalletFactory.getDeployTransaction(deployerAddress, gasOverrides), // Use deployer address as placeholder
+      from: deployerAddress
+    });
+    totalEstimatedCost += factoryGas;
+  }
+  
+  if (!output.forwarderImplementation || !(await isContractDeployed(output.forwarderImplementation))) {
+    const ForwarderV4 = await ethers.getContractFactory(chainConfig.forwarderContractName);
+    const forwarderGas = await deployer.estimateGas({
+      ...await ForwarderV4.getDeployTransaction(gasOverrides),
+      from: deployerAddress
+    });
+    totalEstimatedCost += forwarderGas;
+  }
+  
+  if (!output.forwarderFactory || !(await isContractDeployed(output.forwarderFactory))) {
+    const ForwarderFactory = await ethers.getContractFactory(chainConfig.forwarderFactoryContractName);
+    const forwarderFactoryGas = await deployer.estimateGas({
+      ...await ForwarderFactory.getDeployTransaction(deployerAddress, gasOverrides), // Use deployer address as placeholder
+      from: deployerAddress
+    });
+    totalEstimatedCost += forwarderFactoryGas;
+  }
+  
+  if (totalEstimatedCost > 0n) {
+    // Get gas price for cost calculation
+    const feeData = await ethers.provider.getFeeData();
+    let gasPrice: bigint;
+    
+    if (gasOverrides?.gasPrice) {
+      gasPrice = gasOverrides.gasPrice;
+    } else if (gasOverrides?.maxFeePerGas) {
+      gasPrice = gasOverrides.maxFeePerGas;
+    } else {
+      gasPrice = feeData.gasPrice || 1_000_000_000n; // 1 gwei fallback
+    }
+    
+    const estimatedCost = totalEstimatedCost * gasPrice;
+    
+    await checkSufficientBalance(deployerAddress, estimatedCost, 'all V4 contracts');
+  } else {
+    console.log('✅ All contracts already deployed, skipping balance check');
+  }
+
   // Deploy Wallet Implementation
   const walletAddress = await deployIfNeededAtNonce(
     output.walletImplementation,
@@ -69,7 +134,8 @@ async function main() {
       output.walletImplementation = contract.target as string;
       saveOutput(output);
       return contract.target as string;
-    }
+    },
+    gasOverrides
   );
 
   // Deploy Wallet Factory
@@ -96,7 +162,8 @@ async function main() {
       output.walletFactory = contract.target as string;
       saveOutput(output);
       return contract.target as string;
-    }
+    },
+    gasOverrides
   );
 
   // Deploy Forwarder
@@ -118,7 +185,8 @@ async function main() {
       output.forwarderImplementation = contract.target as string;
       saveOutput(output);
       return contract.target as string;
-    }
+    },
+    gasOverrides
   );
 
   // Deploy Forwarder Factory
@@ -148,7 +216,8 @@ async function main() {
       output.forwarderFactory = contract.target as string;
       saveOutput(output);
       return contract.target as string;
-    }
+    },
+    gasOverrides
   );
 
   console.log(`🎉 All contracts deployed and verified!`);

scripts/deploy.ts

@@ -1,6 +1,6 @@
 import hre, { ethers } from 'hardhat';
 import { Contract } from 'ethers';
-import { logger, waitAndVerify } from '../deployUtils';
+import { logger, waitAndVerify, checkSufficientBalance } from '../deployUtils';
 import fs from 'fs';
 import { setupBigBlocksForBatcherDeployment } from './enableBigBlocks';
 import { isBigBlocksSupported } from '../config/bigBlocksConfig';
@@ -187,6 +187,31 @@ async function main() {
     logger.info(`Using default gas parameters for this network.`);
   }
 
+  // --- 3.5. Balance Check ---
+  logger.step('3.5. Checking deployer balance before deployment...');
+  
+  // Estimate gas cost for the deployment
+  const gasEstimate = await batcherDeployer.estimateGas({
+    ...deployTxReq,
+    from: address,
+    ...gasOverrides
+  });
+  
+  // Calculate total cost
+  let gasPrice: bigint;
+  if (gasOverrides?.gasPrice) {
+    gasPrice = gasOverrides.gasPrice;
+  } else if (gasOverrides?.maxFeePerGas) {
+    gasPrice = gasOverrides.maxFeePerGas;
+  } else {
+    gasPrice = feeData.gasPrice ?? 1_000_000_000n; // 1 gwei fallback
+  }
+  
+  const estimatedCost = gasEstimate * gasPrice;
+  
+  // Check if we have 1.5x the required amount
+  await checkSufficientBalance(address, estimatedCost, 'Batcher');
+
   let batcher: Contract;
   if (gasOverrides) {
     batcher = (await Batcher.deploy(