feat: add interfaces for each abstract contract used by the Starknet …

…core contract #4 (#6)

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

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use crate::{
-    interfaces::{Operator, ProxySupport, StarknetMessaging, StarknetSovereignContract},
+    interfaces::{Operator, ProxySupport, StarknetMessaging, StarknetSovereignContract, StarknetGovernance, GovernedFinalizable},
     LocalMiddleware,
 };
 use ethers::types::Address;
@@ -12,6 +12,8 @@ pub struct StarknetSovereignContractClient {
     messaging: StarknetMessaging<LocalMiddleware>,
     operator: Operator<LocalMiddleware>,
     proxy_support: ProxySupport<LocalMiddleware>,
+    governance: StarknetGovernance<LocalMiddleware>,
+    governed_finalizable: GovernedFinalizable<LocalMiddleware>
 }
 
 impl StarknetSovereignContractClient {
@@ -20,7 +22,9 @@ impl StarknetSovereignContractClient {
             core_contract: StarknetSovereignContract::new(address, client.clone()),
             messaging: StarknetMessaging::new(address, client.clone()),
             operator: Operator::new(address, client.clone()),
-            proxy_support: ProxySupport::new(address, client),
+            proxy_support: ProxySupport::new(address, client.clone()),
+            governance: StarknetGovernance::new(address, client.clone()),
+            governed_finalizable: GovernedFinalizable::new(address, client.clone())
         }
     }
 }
@@ -45,3 +49,13 @@ impl AsRef<Operator<LocalMiddleware>> for StarknetSovereignContractClient {
         &self.operator
     }
 }
+impl AsRef<StarknetGovernance<LocalMiddleware>> for StarknetSovereignContractClient {
+    fn as_ref(&self) -> &StarknetGovernance<LocalMiddleware> {
+        &self.governance
+    }
+}
+impl AsRef<GovernedFinalizable<LocalMiddleware>> for StarknetSovereignContractClient {
+    fn as_ref(&self) -> &GovernedFinalizable<LocalMiddleware> {
+        &self.governed_finalizable
+    }
+}

crates/starknet-core-contract-client/src/interfaces/governance.rs

@@ -0,0 +1,72 @@
+use async_trait::async_trait;
+use ethers::{prelude::abigen, providers::Middleware, types::H160};
+
+use crate::Error;
+
+type Adress = H160;
+
+abigen!(
+    StarknetGovernance,
+    r#"[
+        function starknetIsGovernor(address user) external view returns (bool)
+        function starknetNominateNewGovernor(address newGovernor) external
+        function starknetRemoveGovernor(address governorForRemoval) external
+        function starknetAcceptGovernance() external
+        function starknetCancelNomination() external
+    ]"#,
+);
+
+#[async_trait]
+pub trait StarknetGovernanceTrait<M: Middleware> {
+    async fn starknet_is_governor(&self, user: Adress) -> Result<bool, Error<M>>;
+    async fn starknet_nominate_new_governor(&self, new_governor: Adress) -> Result<(), Error<M>>;
+    async fn starknet_remove_governor(&self, governor_for_removal: Adress) -> Result<(), Error<M>>;
+    async fn starknet_accept_governance(&self) -> Result<(), Error<M>>;
+    async fn starknet_cancel_nomination(&self) -> Result<(), Error<M>>;
+}
+
+#[async_trait]
+impl<T, M: Middleware> StarknetGovernanceTrait<M> for T
+where
+    T: AsRef<StarknetGovernance<M>> + Send + Sync,
+{
+    async fn starknet_is_governor(&self, user: Adress) -> Result<bool, Error<M>> {
+        self.as_ref()
+        .starknet_is_governor(user)
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn starknet_nominate_new_governor(&self, new_governor: Adress) -> Result<(), Error<M>> {
+        self.as_ref()
+        .starknet_nominate_new_governor(new_governor)
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn starknet_remove_governor(&self, governor_for_removal: Adress) -> Result<(), Error<M>> {
+        self.as_ref()
+        .starknet_remove_governor(governor_for_removal)
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn starknet_accept_governance(&self) -> Result<(), Error<M>> {
+        self.as_ref()
+        .starknet_accept_governance()
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn starknet_cancel_nomination(&self) -> Result<(), Error<M>> {
+        self.as_ref()
+        .starknet_cancel_nomination()
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+}

crates/starknet-core-contract-client/src/interfaces/governed_finalizable.rs

@@ -0,0 +1,40 @@
+use async_trait::async_trait;
+use ethers::{prelude::abigen, providers::Middleware};
+
+use crate::Error;
+
+abigen!(
+    GovernedFinalizable,
+    r#"[
+        function isFinalized() public view returns (bool)
+        function finalize() external onlyGovernance notFinalized
+    ]"#,
+);
+
+#[async_trait]
+pub trait GovernedFinalizableTrait<M: Middleware> {
+    async fn is_finalized(&self) -> Result<bool, Error<M>>;
+    async fn finalize(&self) -> Result<(), Error<M>>;
+}
+
+#[async_trait]
+impl<T, M: Middleware> GovernedFinalizableTrait<M> for T
+where
+    T: AsRef<GovernedFinalizable<M>> + Send + Sync,
+{
+    async fn is_finalized(&self) -> Result<bool, Error<M>> {
+        self.as_ref()
+        .is_finalized()
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+
+    async fn finalize(&self) -> Result<(), Error<M>> {
+        self.as_ref()
+        .finalize()
+        .call()
+        .await
+        .map_err(Into::into)
+    }
+}

crates/starknet-core-contract-client/src/interfaces/mod.rs

@@ -3,9 +3,13 @@ mod operator;
 mod proxy_support;
 mod sovereign_core_contract;
 mod validity_core_contract;
+mod governance;
+mod governed_finalizable;
 
 pub use messaging::{StarknetMessaging, StarknetMessagingTrait};
 pub use operator::{Operator, OperatorTrait};
 pub use proxy_support::{ProxySupport, ProxySupportTrait};
 pub use sovereign_core_contract::{StarknetSovereignContract, StarknetSovereignContractTrait};
 pub use validity_core_contract::{StarknetValidityContract, StarknetValidityContractTrait};
+pub use governance::{StarknetGovernance, StarknetGovernanceTrait};
+pub use governed_finalizable::{GovernedFinalizable, GovernedFinalizableTrait};