feat : added different proxy versions in proxy client

crates/l2/starkgate-manager-client/src/clients/starkgate_manager.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use crate::interfaces::manager::StarkgateManager;
-use starknet_proxy_client::proxy_support::ProxySupport;
 use utils::{LocalWalletSignerMiddleware, StarknetContractClient};
 
 use ethers::types::Address;
+use starknet_proxy_client::clients::proxy_5_0_0::ProxySupportLatest;
 
 pub struct StarkgateManagerContractClient {
     manager: StarkgateManager<LocalWalletSignerMiddleware>,
-    proxy_support: ProxySupport<LocalWalletSignerMiddleware>,
+    proxy_support: ProxySupportLatest<LocalWalletSignerMiddleware>,
     manager_implementation: Address,
 }
 
@@ -20,7 +20,7 @@ impl StarkgateManagerContractClient {
     ) -> Self {
         Self {
             manager: StarkgateManager::new(address, client.clone()),
-            proxy_support: ProxySupport::new(address, client.clone()),
+            proxy_support: ProxySupportLatest::new(address, client.clone()),
             manager_implementation: implementation_address,
         }
     }
@@ -32,8 +32,8 @@ impl AsRef<StarkgateManager<LocalWalletSignerMiddleware>> for StarkgateManagerCo
     }
 }
 
-impl AsRef<ProxySupport<LocalWalletSignerMiddleware>> for StarkgateManagerContractClient {
-    fn as_ref(&self) -> &ProxySupport<LocalWalletSignerMiddleware> {
+impl AsRef<ProxySupportLatest<LocalWalletSignerMiddleware>> for StarkgateManagerContractClient {
+    fn as_ref(&self) -> &ProxySupportLatest<LocalWalletSignerMiddleware> {
         &self.proxy_support
     }
 }

crates/l2/starkgate-manager-client/src/lib.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
 use clients::starkgate_manager::StarkgateManagerContractClient;
-use starknet_proxy_client::deploy::{
-    deploy_contract_behind_safe_proxy, deploy_contract_behind_unsafe_proxy, Error,
-};
+use starknet_proxy_client::deploy::{deploy_contract_behind_proxy, Error, ProxyVersion};
 use utils::{LocalWalletSignerMiddleware, NO_CONSTRUCTOR_ARG};
 pub mod clients;
 pub mod interfaces;
@@ -14,24 +12,32 @@ pub async fn deploy_starkgate_manager_behind_unsafe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarkgateManagerContractClient, Error> {
     // Deploy the Starkgate Manager contract (no explicit constructor)
-    let manager_contract =
-        deploy_contract_behind_unsafe_proxy(client.clone(), STARKGATE_MANAGER, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let manager_contract = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKGATE_MANAGER,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::UnsafeProxy,
+    )
+    .await?;
 
     Ok(StarkgateManagerContractClient::new(
-        manager_contract.address(),
+        manager_contract.0.address(),
         client.clone(),
-        manager_contract.address(),
+        manager_contract.1.address(),
     ))
 }
 
 pub async fn deploy_starkgate_manager_behind_safe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarkgateManagerContractClient, Error> {
     // Deploy the Starkgate Manager contract (no explicit constructor)
-    let (manager_contract, manager_contract_implementation) =
-        deploy_contract_behind_safe_proxy(client.clone(), STARKGATE_MANAGER, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let (manager_contract, manager_contract_implementation) = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKGATE_MANAGER,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::SafeProxy5_0_0,
+    )
+    .await?;
 
     Ok(StarkgateManagerContractClient::new(
         manager_contract.address(),

crates/l2/starkgate-registry-client/src/clients/starkgate_registry.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use crate::interfaces::registry::StarkgateRegistry;
-use starknet_proxy_client::proxy_support::ProxySupport;
 use utils::{LocalWalletSignerMiddleware, StarknetContractClient};
 
 use ethers::types::Address;
+use starknet_proxy_client::clients::proxy_5_0_0::ProxySupportLatest;
 
 pub struct StarkgateRegistryContractClient {
     registry: StarkgateRegistry<LocalWalletSignerMiddleware>,
-    proxy_support: ProxySupport<LocalWalletSignerMiddleware>,
+    proxy_support: ProxySupportLatest<LocalWalletSignerMiddleware>,
     registry_implementation: Address,
 }
 
@@ -20,7 +20,7 @@ impl StarkgateRegistryContractClient {
     ) -> Self {
         Self {
             registry: StarkgateRegistry::new(address, client.clone()),
-            proxy_support: ProxySupport::new(address, client.clone()),
+            proxy_support: ProxySupportLatest::new(address, client.clone()),
             registry_implementation: implementation_address,
         }
     }
@@ -31,8 +31,8 @@ impl AsRef<StarkgateRegistry<LocalWalletSignerMiddleware>> for StarkgateRegistry
     }
 }
 
-impl AsRef<ProxySupport<LocalWalletSignerMiddleware>> for StarkgateRegistryContractClient {
-    fn as_ref(&self) -> &ProxySupport<LocalWalletSignerMiddleware> {
+impl AsRef<ProxySupportLatest<LocalWalletSignerMiddleware>> for StarkgateRegistryContractClient {
+    fn as_ref(&self) -> &ProxySupportLatest<LocalWalletSignerMiddleware> {
         &self.proxy_support
     }
 }

crates/l2/starkgate-registry-client/src/lib.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
 use clients::starkgate_registry::StarkgateRegistryContractClient;
-use starknet_proxy_client::deploy::{
-    deploy_contract_behind_safe_proxy, deploy_contract_behind_unsafe_proxy, Error,
-};
+use starknet_proxy_client::deploy::{deploy_contract_behind_proxy, Error, ProxyVersion};
 use utils::{LocalWalletSignerMiddleware, NO_CONSTRUCTOR_ARG};
 
 pub mod clients;
@@ -15,24 +13,32 @@ pub async fn deploy_starkgate_registry_behind_unsafe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarkgateRegistryContractClient, Error> {
     // Deploy the Starkgate Registry contract (no explicit constructor)
-    let registry_contract =
-        deploy_contract_behind_unsafe_proxy(client.clone(), STARKGATE_REGISTRY, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let registry_contract = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKGATE_REGISTRY,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::UnsafeProxy,
+    )
+    .await?;
 
     Ok(StarkgateRegistryContractClient::new(
-        registry_contract.address(),
+        registry_contract.0.address(),
         client.clone(),
-        registry_contract.address(),
+        registry_contract.1.address(),
     ))
 }
 
 pub async fn deploy_starkgate_registry_behind_safe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarkgateRegistryContractClient, Error> {
     // Deploy the Starkgate Registry contract (no explicit constructor)
-    let (registry_contract, registry_contract_implementation) =
-        deploy_contract_behind_safe_proxy(client.clone(), STARKGATE_REGISTRY, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let (registry_contract, registry_contract_implementation) = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKGATE_REGISTRY,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::SafeProxy5_0_0,
+    )
+    .await?;
 
     Ok(StarkgateRegistryContractClient::new(
         registry_contract.address(),

crates/l2/starknet-core-contract-client/src/clients/sovereign.rs

@@ -4,7 +4,7 @@ use crate::interfaces::{
     GovernedFinalizable, Operator, StarknetGovernance, StarknetMessaging, StarknetSovereignContract,
 };
 use ethers::types::Address;
-use starknet_proxy_client::proxy_support::ProxySupport;
+use starknet_proxy_client::clients::proxy_3_0_2::ProxySupport;
 use utils::{LocalWalletSignerMiddleware, StarknetContractClient};
 
 /// Client to interact with a Starknet core contract running in `Sovereign` mode

crates/l2/starknet-core-contract-client/src/clients/validity.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
 use ethers::abi::Address;
+use starknet_proxy_client::clients::proxy_3_0_2::ProxySupport;
 
 use crate::interfaces::{
     GovernedFinalizable, Operator, StarknetGovernance, StarknetMessaging, StarknetValidityContract,
 };
-use starknet_proxy_client::proxy_support::ProxySupport;
 use utils::{LocalWalletSignerMiddleware, StarknetContractClient};
 
 /// Client to interact with a Starknet core contract running in `Validity` mode

crates/l2/starknet-core-contract-client/src/lib.rs

@@ -2,9 +2,7 @@ use std::sync::Arc;
 
 use crate::clients::StarknetValidityContractClient;
 use clients::StarknetSovereignContractClient;
-use starknet_proxy_client::deploy::{
-    deploy_contract_behind_safe_proxy, deploy_contract_behind_unsafe_proxy, Error,
-};
+use starknet_proxy_client::deploy::{deploy_contract_behind_proxy, Error, ProxyVersion};
 use utils::{LocalWalletSignerMiddleware, NO_CONSTRUCTOR_ARG};
 
 pub mod clients;
@@ -19,14 +17,18 @@ pub async fn deploy_starknet_sovereign_behind_unsafe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetSovereignContractClient, Error> {
     // Deploy the Starknet Core contract (no explicit constructor)
-    let core_contract =
-        deploy_contract_behind_unsafe_proxy(client.clone(), STARKNET_SOVEREIGN, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let core_contract = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKNET_SOVEREIGN,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::UnsafeProxy,
+    )
+    .await?;
 
     Ok(StarknetSovereignContractClient::new(
-        core_contract.address(),
+        core_contract.0.address(),
         client.clone(),
-        core_contract.address(),
+        core_contract.1.address(),
     ))
 }
 
@@ -36,9 +38,13 @@ pub async fn deploy_starknet_sovereign_behind_safe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetSovereignContractClient, Error> {
     // Deploy the Starknet Core contract (no explicit constructor)
-    let (core_contract, core_contract_implementation) =
-        deploy_contract_behind_safe_proxy(client.clone(), STARKNET_SOVEREIGN, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let (core_contract, core_contract_implementation) = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKNET_SOVEREIGN,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::SafeProxy3_0_2,
+    )
+    .await?;
 
     Ok(StarknetSovereignContractClient::new(
         core_contract.address(),
@@ -53,13 +59,18 @@ pub async fn deploy_starknet_validity_behind_unsafe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetValidityContractClient, Error> {
     // Deploy the Starknet Core contract (no explicit constructor)
-    let core_contract =
-        deploy_contract_behind_unsafe_proxy(client.clone(), STARKNET, NO_CONSTRUCTOR_ARG).await?;
+    let core_contract = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKNET,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::UnsafeProxy,
+    )
+    .await?;
 
     Ok(StarknetValidityContractClient::new(
-        core_contract.address(),
+        core_contract.0.address(),
         client.clone(),
-        core_contract.address(),
+        core_contract.1.address(),
     ))
 }
 
@@ -69,8 +80,13 @@ pub async fn deploy_starknet_validity_behind_safe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetValidityContractClient, Error> {
     // Deploy the Starknet Core contract (no explicit constructor)
-    let (core_contract, core_contract_implementation) =
-        deploy_contract_behind_safe_proxy(client.clone(), STARKNET, NO_CONSTRUCTOR_ARG).await?;
+    let (core_contract, core_contract_implementation) = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKNET,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::SafeProxy3_0_2,
+    )
+    .await?;
 
     Ok(StarknetValidityContractClient::new(
         core_contract.address(),

crates/l2/starknet-eth-bridge-client/src/clients/eth_bridge.rs

@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
 use crate::interfaces::eth_bridge::StarknetEthBridge;
-use starknet_proxy_client::proxy_support::ProxySupport;
 use utils::{LocalWalletSignerMiddleware, StarknetContractClient};
 
 use ethers::types::Address;
+use starknet_proxy_client::clients::proxy_3_0_2::ProxySupport;
 
 /// Client to interact with a Starknet Eth Bridge
 pub struct StarknetEthBridgeContractClient {

crates/l2/starknet-eth-bridge-client/src/lib.rs

@@ -1,9 +1,7 @@
 use std::sync::Arc;
 
 use clients::eth_bridge::StarknetEthBridgeContractClient;
-use starknet_proxy_client::deploy::{
-    deploy_contract_behind_safe_proxy, deploy_contract_behind_unsafe_proxy, Error,
-};
+use starknet_proxy_client::deploy::{deploy_contract_behind_proxy, Error, ProxyVersion};
 use utils::{LocalWalletSignerMiddleware, NO_CONSTRUCTOR_ARG};
 pub mod clients;
 pub mod interfaces;
@@ -14,27 +12,32 @@ pub async fn deploy_starknet_eth_bridge_behind_unsafe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetEthBridgeContractClient, Error> {
     // Deploy the Eth Bridge contract (no explicit constructor)
-    let eth_bridge_contract = deploy_contract_behind_unsafe_proxy(
+    let eth_bridge_contract = deploy_contract_behind_proxy(
         client.clone(),
         STARKNET_ETH_BRIDGE,
         NO_CONSTRUCTOR_ARG,
+        ProxyVersion::UnsafeProxy,
     )
     .await?;
 
     Ok(StarknetEthBridgeContractClient::new(
-        eth_bridge_contract.address(),
+        eth_bridge_contract.0.address(),
         client.clone(),
-        eth_bridge_contract.address(),
+        eth_bridge_contract.1.address(),
     ))
 }
 
 pub async fn deploy_starknet_eth_bridge_behind_safe_proxy(
     client: Arc<LocalWalletSignerMiddleware>,
 ) -> Result<StarknetEthBridgeContractClient, Error> {
     // Deploy the Eth Bridge contract (no explicit constructor)
-    let (eth_bridge_contract, eth_bridge_contract_implementation) =
-        deploy_contract_behind_safe_proxy(client.clone(), STARKNET_ETH_BRIDGE, NO_CONSTRUCTOR_ARG)
-            .await?;
+    let (eth_bridge_contract, eth_bridge_contract_implementation) = deploy_contract_behind_proxy(
+        client.clone(),
+        STARKNET_ETH_BRIDGE,
+        NO_CONSTRUCTOR_ARG,
+        ProxyVersion::SafeProxy3_0_2,
+    )
+    .await?;
 
     Ok(StarknetEthBridgeContractClient::new(
         eth_bridge_contract.address(),