Fee contract upgrade (#3850)

* upgrade to patch fee contract

* ad version validation and cache removal to allow re-applying

* switch to using builder pattern for upgrade_fee_v1

* only write to stdout if not quiet, ensure fee eoa upgrade verifies owner is not a contract

* removed unused imports

* if applying patch upgrade, then let the user know to remove previous addr

* clippy fix

* remove leftover code

* optimize version checks using the bindings helper

* fix log level, add some more context to some errors

Author: alysiahuggins

contracts/rust/adapter/src/bindings/fee_contract.rs

@@ -16,9 +16,9 @@ use crate::{
     proposals::{
         multisig::{
             transfer_ownership_from_multisig_to_timelock, upgrade_esp_token_v2_multisig_owner,
-            upgrade_light_client_v2_multisig_owner, upgrade_light_client_v3_multisig_owner,
-            upgrade_stake_table_v2_multisig_owner, LightClientV2UpgradeParams,
-            StakeTableV2UpgradeParams, TransferOwnershipParams,
+            upgrade_fee_contract_multisig_owner, upgrade_light_client_v2_multisig_owner,
+            upgrade_light_client_v3_multisig_owner, upgrade_stake_table_v2_multisig_owner,
+            LightClientV2UpgradeParams, StakeTableV2UpgradeParams, TransferOwnershipParams,
         },
         timelock::{
             cancel_timelock_operation, derive_timelock_address_from_contract_type,
@@ -142,35 +142,61 @@ impl<P: Provider + WalletProvider> DeployerArgs<P> {
         let admin = provider.default_signer_address();
         match target {
             Contract::FeeContractProxy => {
-                let addr = crate::deploy_fee_contract_proxy(provider, contracts, admin).await?;
-
-                if let Some(use_timelock_owner) = self.use_timelock_owner {
-                    // FeeContract uses OpsTimelock because:
-                    // - It handles critical fee collection and distribution logic
-                    // - May require emergency updates for security or functionality
-                    // - OpsTimelock provides a shorter delay for critical operations
-                    tracing::info!(
-                        "Transferring ownership to OpsTimelock: {:?}",
-                        use_timelock_owner
-                    );
-                    // deployer is the timelock owner
-                    if use_timelock_owner {
-                        let timelock_addr = derive_timelock_address_from_contract_type(
-                            OwnableContract::FeeContractProxy,
+                if contracts.address(Contract::FeeContractProxy).is_some() {
+                    // Upgrade path
+                    let use_multisig = self.use_multisig;
+                    let dry_run = self.dry_run;
+                    let rpc_url = self.rpc_url.clone();
+
+                    tracing::info!(?dry_run, ?use_multisig, "Upgrading FeeContract to V1.0.1");
+                    if use_multisig {
+                        upgrade_fee_contract_multisig_owner(
+                            provider,
                             contracts,
-                        )?;
+                            rpc_url.to_string(),
+                            dry_run,
+                        )
+                        .await?;
+                    } else {
+                        crate::upgrade_fee_v1(provider, contracts).await?;
+                    }
+                } else {
+                    // Deploy path
+                    let addr = crate::deploy_fee_contract_proxy(provider, contracts, admin).await?;
+
+                    if let Some(use_timelock_owner) = self.use_timelock_owner {
+                        // FeeContract uses OpsTimelock because:
+                        // - It handles critical fee collection and distribution logic
+                        // - May require emergency updates for security or functionality
+                        // - OpsTimelock provides a shorter delay for critical operations
+                        tracing::info!(
+                            "Transferring ownership to OpsTimelock: {:?}",
+                            use_timelock_owner
+                        );
+                        // deployer is the timelock owner
+                        if use_timelock_owner {
+                            let timelock_addr = derive_timelock_address_from_contract_type(
+                                OwnableContract::FeeContractProxy,
+                                contracts,
+                            )?;
+                            crate::transfer_ownership(
+                                provider,
+                                Contract::FeeContractProxy,
+                                addr,
+                                timelock_addr,
+                            )
+                            .await?;
+                        }
+                    } else if let Some(multisig) = self.multisig {
+                        tracing::info!("Transferring ownership to multisig: {:?}", multisig);
                         crate::transfer_ownership(
                             provider,
                             Contract::FeeContractProxy,
                             addr,
-                            timelock_addr,
+                            multisig,
                         )
                         .await?;
                     }
-                } else if let Some(multisig) = self.multisig {
-                    tracing::info!("Transferring ownership to multisig: {:?}", multisig);
-                    crate::transfer_ownership(provider, Contract::FeeContractProxy, addr, multisig)
-                        .await?;
                 }
             },
             Contract::EspTokenProxy => {