diff --git a/contract/src/lib.rs b/contract/src/lib.rs
index bb105be46..a42c379d4 100644
--- a/contract/src/lib.rs
+++ b/contract/src/lib.rs
@@ -1,6 +1,6 @@
 use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
 use near_sdk::serde::{Deserialize, Serialize};
-use near_sdk::{env, near_bindgen, AccountId, PublicKey};
+use near_sdk::{env, near_bindgen, AccountId, PanicOnDefault, PublicKey};
 use std::collections::{HashMap, HashSet};
 
 type ParticipantId = u32;
@@ -25,7 +25,7 @@ pub struct ParticipantInfo {
 }
 
 #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Debug)]
-pub struct InitializedContractState {
+pub struct InitializingContractState {
     pub participants: HashMap<AccountId, ParticipantInfo>,
     pub threshold: usize,
     pub pk_votes: HashMap<PublicKey, HashSet<ParticipantId>>,
@@ -55,32 +55,23 @@ pub struct ResharingContractState {
 
 #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Debug)]
 pub enum ProtocolContractState {
-    NonInitialized,
-    Initialized(InitializedContractState),
+    Initializing(InitializingContractState),
     Running(RunningContractState),
     Resharing(ResharingContractState),
 }
 
 #[near_bindgen]
-#[derive(BorshDeserialize, BorshSerialize)]
+#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)]
 pub struct MpcContract {
     protocol_state: ProtocolContractState,
 }
 
-impl Default for MpcContract {
-    fn default() -> Self {
-        Self {
-            protocol_state: ProtocolContractState::NonInitialized,
-        }
-    }
-}
-
 #[near_bindgen]
 impl MpcContract {
     #[init]
     pub fn init(threshold: usize, participants: HashMap<AccountId, ParticipantInfo>) -> Self {
         MpcContract {
-            protocol_state: ProtocolContractState::Initialized(InitializedContractState {
+            protocol_state: ProtocolContractState::Initializing(InitializingContractState {
                 participants,
                 threshold,
                 pk_votes: HashMap::new(),
@@ -112,9 +103,6 @@ impl MpcContract {
                     },
                 );
             }
-            ProtocolContractState::NonInitialized => {
-                env::panic_str("protocol state hasn't been initialized yet")
-            }
             _ => env::panic_str("protocol state can't accept new participants right now"),
         }
     }
@@ -157,9 +145,6 @@ impl MpcContract {
                     false
                 }
             }
-            ProtocolContractState::NonInitialized => {
-                env::panic_str("protocol state hasn't been initialized yet")
-            }
             _ => env::panic_str("protocol state can't accept new participants right now"),
         }
     }
@@ -202,16 +187,13 @@ impl MpcContract {
                     false
                 }
             }
-            ProtocolContractState::NonInitialized => {
-                env::panic_str("protocol state hasn't been initialized yet")
-            }
             _ => env::panic_str("protocol state can't kick participants right now"),
         }
     }
 
     pub fn vote_pk(&mut self, public_key: PublicKey) -> bool {
         match &mut self.protocol_state {
-            ProtocolContractState::Initialized(InitializedContractState {
+            ProtocolContractState::Initializing(InitializingContractState {
                 participants,
                 threshold,
                 pk_votes,
@@ -238,9 +220,6 @@ impl MpcContract {
                     false
                 }
             }
-            ProtocolContractState::NonInitialized => {
-                env::panic_str("protocol state hasn't been initialized yet")
-            }
             ProtocolContractState::Running(state) if state.public_key == public_key => true,
             ProtocolContractState::Resharing(state) if state.public_key == public_key => true,
             _ => env::panic_str("can't change public key anymore"),
@@ -281,9 +260,6 @@ impl MpcContract {
                     false
                 }
             }
-            ProtocolContractState::NonInitialized => {
-                env::panic_str("protocol state hasn't been initialized yet")
-            }
             ProtocolContractState::Running(state) => {
                 if state.epoch == epoch {
                     true
diff --git a/node/src/protocol/consensus.rs b/node/src/protocol/consensus.rs
index df2af5d33..6cab58e1d 100644
--- a/node/src/protocol/consensus.rs
+++ b/node/src/protocol/consensus.rs
@@ -66,7 +66,7 @@ impl ConsensusProtocol for StartedState {
                 private_share,
                 public_key,
             }) => match contract_state {
-                ProtocolState::Initialized(_) => Err(ConsensusError::ContractStateRollback),
+                ProtocolState::Initializing(_) => Err(ConsensusError::ContractStateRollback),
                 ProtocolState::Running(contract_state) => {
                     if contract_state.public_key != public_key {
                         return Err(ConsensusError::MismatchedPublicKey);
@@ -131,7 +131,7 @@ impl ConsensusProtocol for StartedState {
                 }
             },
             None => match contract_state {
-                ProtocolState::Initialized(contract_state) => {
+                ProtocolState::Initializing(contract_state) => {
                     if contract_state.participants.contains_key(&ctx.me()) {
                         tracing::info!("starting key generation as a part of the participant set");
                         let participants = contract_state.participants;
@@ -169,7 +169,7 @@ impl ConsensusProtocol for GeneratingState {
         contract_state: ProtocolState,
     ) -> Result<NodeState, ConsensusError> {
         match contract_state {
-            ProtocolState::Initialized(_) => {
+            ProtocolState::Initializing(_) => {
                 tracing::debug!("continuing generation, contract state has not been finalized yet");
                 Ok(NodeState::Generating(self))
             }
@@ -217,7 +217,7 @@ impl ConsensusProtocol for WaitingForConsensusState {
         contract_state: ProtocolState,
     ) -> Result<NodeState, ConsensusError> {
         match contract_state {
-            ProtocolState::Initialized(contract_state) => {
+            ProtocolState::Initializing(contract_state) => {
                 tracing::debug!("waiting for consensus, contract state has not been finalized yet");
                 let public_key = self.public_key.into_near_public_key();
                 let has_voted = contract_state
@@ -338,7 +338,7 @@ impl ConsensusProtocol for RunningState {
         contract_state: ProtocolState,
     ) -> Result<NodeState, ConsensusError> {
         match contract_state {
-            ProtocolState::Initialized(_) => Err(ConsensusError::ContractStateRollback),
+            ProtocolState::Initializing(_) => Err(ConsensusError::ContractStateRollback),
             ProtocolState::Running(contract_state) => match contract_state.epoch.cmp(&self.epoch) {
                 Ordering::Greater => {
                     tracing::warn!(
@@ -404,7 +404,7 @@ impl ConsensusProtocol for ResharingState {
         contract_state: ProtocolState,
     ) -> Result<NodeState, ConsensusError> {
         match contract_state {
-            ProtocolState::Initialized(_) => Err(ConsensusError::ContractStateRollback),
+            ProtocolState::Initializing(_) => Err(ConsensusError::ContractStateRollback),
             ProtocolState::Running(contract_state) => {
                 match contract_state.epoch.cmp(&(self.old_epoch + 1)) {
                     Ordering::Greater => {
@@ -476,7 +476,7 @@ impl ConsensusProtocol for JoiningState {
         contract_state: ProtocolState,
     ) -> Result<NodeState, ConsensusError> {
         match contract_state {
-            ProtocolState::Initialized(_) => Err(ConsensusError::ContractStateRollback),
+            ProtocolState::Initializing(_) => Err(ConsensusError::ContractStateRollback),
             ProtocolState::Running(contract_state) => {
                 if contract_state.candidates.contains_key(&ctx.me()) {
                     let voted = contract_state
diff --git a/node/src/protocol/contract.rs b/node/src/protocol/contract.rs
index e120fd2bc..e6075dde6 100644
--- a/node/src/protocol/contract.rs
+++ b/node/src/protocol/contract.rs
@@ -8,15 +8,15 @@ use std::collections::{HashMap, HashSet};
 use url::Url;
 
 #[derive(Serialize, Deserialize, Debug)]
-pub struct InitializedContractState {
+pub struct InitializingContractState {
     pub participants: HashMap<Participant, Url>,
     pub threshold: usize,
     pub pk_votes: HashMap<near_crypto::PublicKey, HashSet<Participant>>,
 }
 
-impl From<mpc_contract::InitializedContractState> for InitializedContractState {
-    fn from(value: mpc_contract::InitializedContractState) -> Self {
-        InitializedContractState {
+impl From<mpc_contract::InitializingContractState> for InitializingContractState {
+    fn from(value: mpc_contract::InitializingContractState) -> Self {
+        InitializingContractState {
             participants: contract_participants_into_cait_participants(value.participants),
             threshold: value.threshold,
             pk_votes: value
@@ -114,7 +114,7 @@ impl From<mpc_contract::ResharingContractState> for ResharingContractState {
 
 #[derive(Debug)]
 pub enum ProtocolState {
-    Initialized(InitializedContractState),
+    Initializing(InitializingContractState),
     Running(RunningContractState),
     Resharing(ResharingContractState),
 }
@@ -122,7 +122,7 @@ pub enum ProtocolState {
 impl ProtocolState {
     pub fn participants(&self) -> &HashMap<Participant, Url> {
         match self {
-            ProtocolState::Initialized(InitializedContractState { participants, .. }) => {
+            ProtocolState::Initializing(InitializingContractState { participants, .. }) => {
                 participants
             }
             ProtocolState::Running(RunningContractState { participants, .. }) => participants,
@@ -134,7 +134,7 @@ impl ProtocolState {
 
     pub fn public_key(&self) -> Option<&PublicKey> {
         match self {
-            ProtocolState::Initialized { .. } => None,
+            ProtocolState::Initializing { .. } => None,
             ProtocolState::Running(RunningContractState { public_key, .. }) => Some(public_key),
             ProtocolState::Resharing(ResharingContractState { public_key, .. }) => Some(public_key),
         }
@@ -142,7 +142,7 @@ impl ProtocolState {
 
     pub fn threshold(&self) -> usize {
         match self {
-            ProtocolState::Initialized(InitializedContractState { threshold, .. }) => *threshold,
+            ProtocolState::Initializing(InitializingContractState { threshold, .. }) => *threshold,
             ProtocolState::Running(RunningContractState { threshold, .. }) => *threshold,
             ProtocolState::Resharing(ResharingContractState { threshold, .. }) => *threshold,
         }
@@ -154,9 +154,8 @@ impl TryFrom<ProtocolContractState> for ProtocolState {
 
     fn try_from(value: ProtocolContractState) -> Result<Self, Self::Error> {
         match value {
-            ProtocolContractState::NonInitialized => Err(()),
-            ProtocolContractState::Initialized(state) => {
-                Ok(ProtocolState::Initialized(state.into()))
+            ProtocolContractState::Initializing(state) => {
+                Ok(ProtocolState::Initializing(state.into()))
             }
             ProtocolContractState::Running(state) => Ok(ProtocolState::Running(state.into())),
             ProtocolContractState::Resharing(state) => Ok(ProtocolState::Resharing(state.into())),