From 4947c6df64575df7efddcd0c41e63e49138c1a5c Mon Sep 17 00:00:00 2001 From: salman01zp Date: Wed, 8 May 2024 00:21:52 +0530 Subject: [PATCH] transfer ownership --- Cargo.lock | 2 - Cargo.toml | 3 +- crates/relayer-store/src/lib.rs | 7 +- .../evm/src/signature_bridge_watcher.rs | 68 +++++-------------- .../tangle/src/job_result_handler.rs | 61 ++++++++++++++++- services/webb-relayer/src/service/tangle.rs | 5 +- 6 files changed, 81 insertions(+), 65 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 775f3720..83514fc6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7104,8 +7104,6 @@ dependencies = [ [[package]] name = "webb" version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6ca5741c27f380e4ac74b2ecd2a1b8d226282808dcc309ad1cd4e4057c876ada" dependencies = [ "async-trait", "ethers", diff --git a/Cargo.toml b/Cargo.toml index b32a10a6..b56e21a2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -43,7 +43,8 @@ tokio = { version = "^1", features = ["full"] } config = { version = "0.13", default-features = false, features = ["toml", "json"] } serde_json = { version = "^1", default-features = false, features = ["raw_value"] } paw = { version = "^1.0" } -webb = { version = "0.8.5", default-features = false } +#webb = { version = "0.8.5", default-features = false } +webb = { path = "/Users/salman/Webb-tools/webb-rs", default-features = false} subxt-signer = { version = "0.34", features = ["subxt"] } # Used by ethers (but we need it to be vendored with the lib). native-tls = { version = "^0.2", features = ["vendored"] } diff --git a/crates/relayer-store/src/lib.rs b/crates/relayer-store/src/lib.rs index 491c4d86..e6ed89b9 100644 --- a/crates/relayer-store/src/lib.rs +++ b/crates/relayer-store/src/lib.rs @@ -356,12 +356,9 @@ pub enum BridgeCommand { }, /// A Command sent to the Signature Bridge to transfer the ownership of the bridge TransferOwnership { - voter_merkle_root: [u8; 32], - session_length: u64, - voter_count: u32, - nonce: u32, + job_id: u64, pub_key: Vec, - /// The signature of the hash of the nonce+public key, Signed by the proposal signing + /// The signature of the hash of the public key, Signed by the proposal signing /// backend. signature: Vec, }, diff --git a/event-watchers/evm/src/signature_bridge_watcher.rs b/event-watchers/evm/src/signature_bridge_watcher.rs index 61dbc558..d85d7a3d 100644 --- a/event-watchers/evm/src/signature_bridge_watcher.rs +++ b/event-watchers/evm/src/signature_bridge_watcher.rs @@ -191,24 +191,14 @@ impl BridgeWatcher for SignatureBridgeContractWatcher { .await?; } TransferOwnership { + job_id, pub_key, - nonce, - voter_merkle_root, - voter_count, - session_length, signature, } => { self.transfer_ownership_with_signature( store, &wrapper.contract, - ( - pub_key, - nonce, - voter_merkle_root, - voter_count, - session_length, - signature, - ), + (job_id, pub_key, signature), ) .await? } @@ -364,14 +354,7 @@ where &self, store: Arc<::Store>, contract: &SignatureBridgeContract, - ( - public_key, - nonce, - voter_merkle_root, - voter_count, - session_length, - signature, - ): (Vec, u32, [u8; 32], u32, u64, Vec), + (job_id, public_key, signature): (u64, Vec, Vec), ) -> webb_relayer_utils::Result<()> { // before doing anything, we need to do just two things: // 1. check if we already have this transaction in the queue. @@ -396,7 +379,7 @@ where } // we need to do some checks here: // 1. convert the public key to address and check it is not the same as the current governor. - // 2. check if the nonce is greater than the current nonce. + // 2. check if the job_id of new governor is greater than the current. // 3. ~check if the signature is valid.~ let current_governor_address = contract.governor().call().await?; if new_governor_address == current_governor_address { @@ -404,37 +387,27 @@ where %new_governor_address, %current_governor_address, public_key = %hex::encode(&public_key), - %nonce, + %job_id, signature = %hex::encode(&signature), "Skipping transfer ownership since the new governor is the same as the current one", ); return Ok(()); } + // JobId of the current governor + let current_job_id = contract.job_id().call().await?; - let refresh_nonce = contract.refresh_nonce().call().await?; - - // require(refreshNonce < nonce, "Invalid nonce") - if nonce < refresh_nonce { - tracing::warn!( - %refresh_nonce, - %nonce, - public_key = %hex::encode(&public_key), - signature = %hex::encode(&signature), - "Skipping transfer ownership since the nonce is less than the refresh nonce", - ); - return Ok(()); - } - // require(nonce <= refreshNonce + 1, "Nonce must increment by 1"); - if nonce != refresh_nonce + 1 { + // require( job_id > current_job_id, "Invalid Job Id") + if job_id < current_job_id { tracing::warn!( - %refresh_nonce, - %nonce, + %current_job_id, + %job_id, public_key = %hex::encode(&public_key), signature = %hex::encode(&signature), - "Skipping transfer ownership since the nonce must increment by 1", + "Skipping transfer ownership since new job id is less than the current one", ); return Ok(()); } + tracing::event!( target: webb_relayer_utils::probe::TARGET, tracing::Level::DEBUG, @@ -442,19 +415,13 @@ where call = "transfer_ownership_with_signature", chain_id = %chain_id.as_u64(), public_key = %hex::encode(&public_key), - %nonce, - voter_merkle_root = %hex::encode(voter_merkle_root), - %voter_count, - %session_length, + %job_id, signature = %hex::encode(&signature), ); // estimated gas let estimate_gas = contract .transfer_ownership_with_signature( - voter_merkle_root, - session_length, - voter_count, - nonce, + job_id.clone(), public_key.clone().into(), signature.clone().into(), ) @@ -464,10 +431,7 @@ where // get the current governor nonce. let call = contract .transfer_ownership_with_signature( - voter_merkle_root, - session_length, - voter_count, - nonce, + job_id.clone(), public_key.into(), signature.into(), ) diff --git a/event-watchers/tangle/src/job_result_handler.rs b/event-watchers/tangle/src/job_result_handler.rs index b09a4d0a..06b42370 100644 --- a/event-watchers/tangle/src/job_result_handler.rs +++ b/event-watchers/tangle/src/job_result_handler.rs @@ -27,8 +27,16 @@ use webb_relayer_utils::{metric, TangleRuntimeConfig}; use webb_event_watcher_traits::substrate::EventHandler; /// JobResultHandler handles the `JobResultSubmitted` event. -#[derive(Copy, Clone, Debug, Default)] -pub struct JobResultHandler; +#[derive(Clone, Debug)] +pub struct JobResultHandler { + relayer_config: webb_relayer_config::WebbRelayerConfig, +} + +impl JobResultHandler { + pub fn new(relayer_config: webb_relayer_config::WebbRelayerConfig) -> Self { + Self { relayer_config } + } +} #[async_trait::async_trait] impl EventHandler for JobResultHandler { @@ -79,9 +87,10 @@ impl EventHandler for JobResultHandler { .collect(); for event in job_result_submitted_events { // Fetch submitted job result + let job_id = event.clone().job_id; let known_result_addrs = RuntimeApi::storage() .jobs() - .known_results(event.clone().role_type, event.clone().job_id); + .known_results(event.clone().role_type, job_id.clone()); let maybe_result = client .storage() @@ -129,6 +138,52 @@ impl EventHandler for JobResultHandler { item, )?; } + + JobResult::DKGPhaseFour(result) => { + tracing::debug!("DKG Phase Four result received"); + let mut bridge_keys = Vec::new(); + for (_, config) in self.relayer_config.evm.iter() { + let typed_chain_id = + webb_proposals::TypedChainId::Evm( + config.chain_id, + ); + let bridge_key = BridgeKey::new(typed_chain_id); + bridge_keys.push(bridge_key); + } + + // Now we just signal every signature bridge to transfer the ownership. + for bridge_key in bridge_keys { + tracing::debug!( + %bridge_key, + ?event, + "Signaling Signature Bridge to transfer ownership", + ); + tracing::event!( + target: webb_relayer_utils::probe::TARGET, + tracing::Level::DEBUG, + kind = %webb_relayer_utils::probe::Kind::SigningBackend, + backend = "DKG", + signal_bridge = %bridge_key, + public_key = %hex::encode(&result.key.clone().0), + previoud_job_id = %result.phase_one_id, + new_job_id = %result.new_phase_one_id, + signature = %hex::encode(&result.signature.clone().0), + ); + + let item = QueueItem::new( + BridgeCommand::TransferOwnership { + job_id: result.new_phase_one_id, + pub_key: result.key.clone().0, + signature: result.signature.clone().0, + }, + ); + + store.enqueue_item( + SledQueueKey::from_bridge_key(bridge_key), + item, + )?; + } + } _ => unimplemented!("Phase results not supported"), } } diff --git a/services/webb-relayer/src/service/tangle.rs b/services/webb-relayer/src/service/tangle.rs index 24f98a40..bf40ab12 100644 --- a/services/webb-relayer/src/service/tangle.rs +++ b/services/webb-relayer/src/service/tangle.rs @@ -84,10 +84,11 @@ pub fn start_job_result_watcher( tracing::debug!("Job Result events watcher for ({}) Started.", chain_id,); let mut shutdown_signal = ctx.shutdown_signal(); let metrics = ctx.metrics.clone(); + let webb_config = ctx.config.clone(); let my_config = config.clone(); let task = async move { - let job_result_watcher = JobResultWatcher; - let job_result_event_handler = JobResultHandler; + let job_result_watcher = JobResultWatcher::default(); + let job_result_event_handler = JobResultHandler::new(webb_config); let job_result_watcher_task = job_result_watcher.run( chain_id, ctx.clone(),