Reset fee multiplier and bump telemetry (#1343)

* Reset fee multiplier and bump telemetry

* Fix fees and force multiplier reset

* Updated the fork block height constant to 23_202_222

* remove pre-commit hook

* restore chain specs

* add back pre-commit hook

* restore old chain specs

* refine queue handling

* update for CI

Author: takemiyamakoto

.github/workflows/static_analysis.yml

@@ -50,7 +50,7 @@ jobs:
         shell: bash
 
       - name: Upload SARIF file
-        if: always()
+        if: ${{ always() && hashFiles('results.sarif') != '' }}
         # v2.24.2
         uses: github/codeql-action/upload-sarif@49abf0ba24d0b7953cb586944e918a0b92074c80
         with:

.gitignore

@@ -8,6 +8,8 @@
 
 # The cache for chain data in container
 .local
+.cargo/*
+.cargo*
 
 local-test
 

BRIDGE.md

@@ -153,3 +153,16 @@ Easiest way is to use `ethApp.burn` and `erc20App.burn` via polkadot.js/apps
 
 ### Ethereum to Sora
 Example placed in `bridge-scripts/transfer-eth.sh`
+
+## Operational Runbook
+
+### Clearing Stalled Outgoing Requests
+
+If an outgoing request collects signatures but cannot finalize (for example because the bridge account lacks funds), the pallet keeps the existing approvals. Once the underlying issue is fixed, clear the stale signatures before peers vote again:
+
+1. Use a root session (sudo in polkadot.js/apps) and call the extrinsic  
+   `ethBridge.resetRequestSignatures(network_id, request_hash)`.
+2. Confirm the runtime emits `ethBridge.RequestSignaturesCleared`.
+3. The request status should remain `Failed` or `Broken`; resubmit or re-run the approval flow as appropriate.
+
+This explicit reset replaces the old behaviour where signatures were wiped automatically on failure, preventing accidental loss of evidence while still giving operators a deterministic recovery step.

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "framenode"
-version = "4.7.0"
+version = "4.7.1"
 authors = ["Parity Technologies <admin@parity.io>"]
 build = "build.rs"
 edition = "2021"
@@ -103,8 +103,6 @@ rayon = "=1.10.0"
 rayon-core = "=1.12.1"
 url = "=2.5.2"
 static_init = "=1.0.3"
-netlink-proto = "=0.10.0"
-if-watch = "=3.2.0"
 backtrace = "=0.3.74"
 derive_more = "=0.99.18"
 scale-info = "=2.11.3"
@@ -127,6 +125,11 @@ pallet-sudo = { git = "https://github.com/sora-xor/substrate.git", branch = "pol
 
 framenode-chain-spec = { path = "chain_spec", features = ["test"] }
 
+# Linux-only netlink dependencies (do not compile on macOS)
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+netlink-proto = "=0.10.0"
+if-watch = "=3.2.0"
+
 [features]
 include-real-files = []
 

node/Cargo.toml

@@ -393,10 +393,12 @@ pub mod pallet {
         >;
 
         type Denominator: common::Denominator<Self::AssetId, Balance>;
+        /// Maximum number of requests that can be queued per network.
+        type MaxRequestsPerQueue: Get<u32>;
     }
 
     /// The current storage version.
-    const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
+    const STORAGE_VERSION: StorageVersion = StorageVersion::new(2);
 
     #[pallet::pallet]
     #[pallet::generate_store(pub(super) trait Store)]
@@ -1038,6 +1040,36 @@ pub mod pallet {
             SidechainAssetPrecision::<T>::insert(network_id, &asset_id, precision);
             Ok(().into())
         }
+
+        /// Explicitly clear collected signatures for a request.
+        ///
+        /// Used by operators to recover from failed finalization without implicitly wiping
+        /// approvals on-chain.
+        #[pallet::call_index(17)]
+        #[pallet::weight(EXTRINSIC_FIXED_WEIGHT)]
+        pub fn reset_request_signatures(
+            origin: OriginFor<T>,
+            network_id: BridgeNetworkId<T>,
+            hash: H256,
+        ) -> DispatchResultWithPostInfo {
+            ensure_root(origin)?;
+            let status =
+                RequestStatuses::<T>::get(network_id, &hash).ok_or(Error::<T>::UnknownRequest)?;
+            ensure!(
+                matches!(
+                    status,
+                    RequestStatus::Failed(_) | RequestStatus::Broken(_, _)
+                ),
+                Error::<T>::RequestStatusNotResettable
+            );
+            ensure!(
+                Requests::<T>::contains_key(network_id, &hash),
+                Error::<T>::UnknownRequest
+            );
+            Self::clear_request_signatures(network_id, &hash);
+            Self::deposit_event(Event::RequestSignaturesCleared(hash));
+            Ok(().into())
+        }
     }
 
     #[pallet::event]
@@ -1059,6 +1091,8 @@ pub mod pallet {
         CancellationFailed(H256),
         /// The request registration has been failed. [Request Hash, Error]
         RegisterRequestFailed(H256, DispatchError),
+        /// Operators cleared stored signatures for a request. [Request Hash]
+        RequestSignaturesCleared(H256),
     }
 
     #[cfg_attr(test, derive(PartialEq, Eq))]
@@ -1224,6 +1258,10 @@ pub mod pallet {
         Other,
         /// Expected pending request.
         ExpectedPendingRequest,
+        /// Too many requests queued for the network.
+        RequestsQueueFull,
+        /// Signatures can only be reset when a request failed or is broken.
+        RequestStatusNotResettable,
         /// Expected Ethereum network.
         ExpectedEthNetwork,
         /// Request was removed and refunded.
@@ -1309,6 +1347,18 @@ pub mod pallet {
         ValueQuery,
     >;
 
+    /// Outgoing request approval authors.
+    #[pallet::storage]
+    pub(super) type RequestApprovers<T: Config> = StorageDoubleMap<
+        _,
+        Twox64Concat,
+        BridgeNetworkId<T>,
+        Identity,
+        H256,
+        BTreeSet<T::AccountId>,
+        ValueQuery,
+    >;
+
     /// Requests made by an account.
     #[pallet::storage]
     #[pallet::getter(fn account_requests)]
@@ -1574,11 +1624,17 @@ impl<T: Config> Pallet<T> {
                 Error::<T>::DuplicatedRequest
             );
         }
+        let queue_len = RequestsQueue::<T>::get(net_id).len();
+        ensure!(
+            queue_len < T::MaxRequestsPerQueue::get() as usize,
+            Error::<T>::RequestsQueueFull
+        );
         request.validate()?;
         request.prepare()?;
+        Self::clear_request_signatures(net_id, &hash);
         AccountRequests::<T>::mutate(&request.author(), |vec| vec.push((net_id, hash)));
         Requests::<T>::insert(net_id, &hash, request);
-        RequestsQueue::<T>::mutate(net_id, |v| v.push(hash));
+        RequestsQueue::<T>::mutate(net_id, |queue| queue.push(hash));
         RequestStatuses::<T>::insert(net_id, &hash, RequestStatus::Pending);
         let block_number = frame_system::Pallet::<T>::current_block_number();
         RequestSubmissionHeight::<T>::insert(net_id, &hash, block_number);
@@ -1603,13 +1659,6 @@ impl<T: Config> Pallet<T> {
             !Requests::<T>::contains_key(network_id, incoming_request_hash),
             Error::<T>::RequestIsAlreadyRegistered
         );
-        Self::remove_request_from_queue(network_id, &sidechain_tx_hash);
-        RequestStatuses::<T>::insert(network_id, sidechain_tx_hash, RequestStatus::Done);
-        LoadToIncomingRequestHash::<T>::insert(
-            network_id,
-            sidechain_tx_hash,
-            incoming_request_hash,
-        );
         if let Err(e) = incoming_request
             .validate()
             .and_then(|_| incoming_request.prepare())
@@ -1623,12 +1672,24 @@ impl<T: Config> Pallet<T> {
             Self::deposit_event(Event::RegisterRequestFailed(incoming_request_hash, e));
             return Ok(incoming_request_hash);
         }
+        let queue_len = RequestsQueue::<T>::get(network_id).len();
+        ensure!(
+            queue_len < T::MaxRequestsPerQueue::get() as usize,
+            Error::<T>::RequestsQueueFull
+        );
         Requests::<T>::insert(network_id, &incoming_request_hash, incoming_request);
-        RequestsQueue::<T>::mutate(network_id, |v| v.push(incoming_request_hash));
+        RequestsQueue::<T>::mutate(network_id, |queue| queue.push(incoming_request_hash));
         RequestStatuses::<T>::insert(network_id, incoming_request_hash, RequestStatus::Pending);
         AccountRequests::<T>::mutate(request_author, |v| {
             v.push((network_id, incoming_request_hash))
         });
+        Self::remove_request_from_queue(network_id, &sidechain_tx_hash);
+        RequestStatuses::<T>::insert(network_id, sidechain_tx_hash, RequestStatus::Done);
+        LoadToIncomingRequestHash::<T>::insert(
+            network_id,
+            sidechain_tx_hash,
+            incoming_request_hash,
+        );
         Ok(incoming_request_hash)
     }
 
@@ -1669,6 +1730,12 @@ impl<T: Config> Pallet<T> {
         });
     }
 
+    #[inline]
+    pub(crate) fn clear_request_signatures(network_id: T::NetworkId, hash: &H256) {
+        RequestApprovals::<T>::remove(network_id, hash);
+        RequestApprovers::<T>::remove(network_id, hash);
+    }
+
     /// Registers new sidechain asset and grants mint permission to the bridge account.
     fn register_sidechain_asset(
         token_address: EthAddress,
@@ -1785,6 +1852,7 @@ impl<T: Config> Pallet<T> {
         }
         info!("Verified request approve {:?}", request_encoded);
         let mut approvals = RequestApprovals::<T>::get(net_id, &hash);
+        let mut approvers = RequestApprovers::<T>::get(net_id, &hash);
         let pending_peers_len = if Self::is_additional_signature_needed(net_id, &request) {
             1
         } else {
@@ -1793,8 +1861,17 @@ impl<T: Config> Pallet<T> {
         let need_sigs = majority(Self::peers(net_id).len()) + pending_peers_len;
         let current_status =
             RequestStatuses::<T>::get(net_id, &hash).ok_or(Error::<T>::UnknownRequest)?;
+        if !approvers.insert(author.clone()) {
+            debug!(
+                "Peer {:?} attempted to resubmit approval for {:?}",
+                author, hash
+            );
+            RequestApprovers::<T>::insert(net_id, &hash, &approvers);
+            return Ok(None);
+        }
         approvals.insert(signature_params);
         RequestApprovals::<T>::insert(net_id, &hash, &approvals);
+        RequestApprovers::<T>::insert(net_id, &hash, &approvers);
         if current_status == RequestStatus::Pending && approvals.len() == need_sigs {
             if let Err(err) = request.finalize(hash) {
                 error!("Outgoing request finalization failed: {:?}", err);

pallets/eth-bridge/src/lib.rs

@@ -13,6 +13,7 @@ macro_rules! cancel {
             debug_assert!(false, "unexpected cancellation error {:?}", e);
         } else {
             crate::RequestStatuses::<T>::insert($net_id, $hash, RequestStatus::Failed($err));
+            Self::clear_request_signatures($net_id, &$hash);
         }
     };
 }

pallets/eth-bridge/src/macros.rs

@@ -477,7 +477,7 @@ impl<T: Config> IncomingCancelOutgoingRequest<T> {
             hash,
             RequestStatus::Failed(Error::<T>::Cancelled.into()),
         );
-        crate::RequestApprovals::<T>::take(net_id, hash);
+        crate::Pallet::<T>::clear_request_signatures(net_id, hash);
         Ok(self.initial_request_hash)
     }