Merge reality back to main

.github/workflows/ci-bridge.yml

@@ -24,7 +24,7 @@ jobs:
       - name: Install Foundry
         uses: foundry-rs/foundry-toolchain@v1
         with:
-          version: nightly
+          version: stable
 
       - name: Run Foundry tests
         run: forge test --gas-limit 2000000000000 # arbitrary, but seemingly no way to disable entirely.

.github/workflows/cicd-prd.yml

@@ -5,6 +5,7 @@ on:
   push:
     branches:
       - main
+  workflow_dispatch:
   # On released
   release:
     types: [published]

.trunk/trunk.yaml

@@ -1,36 +1,43 @@
+# This file controls the behavior of Trunk: https://docs.trunk.io/cli
+# To learn more about the format of this file,
+# see https://docs.trunk.io/reference/trunk-yaml
 version: 0.1
 cli:
-  version: 1.22.3
+  version: 1.22.4
+# Trunk provides extensibility via plugins.
+# (https://docs.trunk.io/plugins)
 plugins:
   sources:
     - id: trunk
       ref: v1.6.2
       uri: https://github.com/trunk-io/plugins
-
+# Many linters and tools depend on runtimes -
+# configure them here. (https://docs.trunk.io/runtimes)
+runtimes:
+  enabled:
+    - [email protected]
+    - [email protected]
+# This is the section where you manage your linters.
+# (https://docs.trunk.io/check/configuration)
 lint:
   enabled:
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
     - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
+    - [email protected]
+    - [email protected]
     - git-diff-check
+    - [email protected]
     - [email protected]
+    - [email protected]
+    - [email protected]
     - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    - [email protected]
-    # - [email protected] - removed for being over-prissy and wanting tab indents - rrw 2023-04-25
+    - [email protected]
+    - [email protected]
+    - [email protected]
+    - [email protected]
   ignore:
+    - linters: [osv-scanner]
+      paths:
+        - scilla-contracts/**
     - linters: [gitleaks]
       paths:
         - smart-contracts/script/config.ts
@@ -39,6 +46,7 @@ lint:
     - linters: [eslint]
       paths:
         - bridge-web
+        - scilla-contracts
     - linters: [ALL]
       paths:
         - .devcontainer/*
@@ -57,15 +65,13 @@ lint:
         - "**/templates/*"
         - "templates/**"
         - "**/templates/**"
+        - smart-contracts/broadcast/**
+        - smart-contracts/test/zilbridge/tokens/switcheo/**
 
-runtimes:
-  enabled:
-    - [email protected]
-    - [email protected]
-    - [email protected]
 actions:
-  enabled:
+  disabled:
     - trunk-announce
     - trunk-check-pre-push
     - trunk-fmt-pre-commit
+  enabled:
     - trunk-upgrade-available

bridge-validators/config.toml

@@ -42,6 +42,13 @@ legacy_gas_estimation_percent = 130
 ## fetching the receipt and scanning it for relevant logs. This is slow, but at least it works ..
 ## use_get_transactions = true
 
+## Defines the exception set - events that should be treated like other events.
+## This is used for exceptional reprocessing of bridge transactions that have been generated
+## as the result of bugs and need to be reprocessed.
+## Annoyingly, the exceptions must be single-line as otherwise the toml parser will complain.
+##exceptions = [
+## { transaction_id = "0xa4738bffe20fff0d71d449685ad8e252dc2645948034d0e1ca12772422744b0c", block_hash="0xb71c1c134044480d1ffd1b7822382769b160b38729a27b35d14c5093b93911c9", block_number=46770995, chain_id="0x61", replacement_bytes="0x00000000000000000000000041823941d00f47ea1a98d75586915bf828f4a038000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000f4240000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e41a90748a000000000000000000000000000000000000000000000000000000000000006100000000000000000000000036b8a9cd6bf9bfa5984093005cf81cafb1bf06f7000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000600000000000000000000000009be4dcfb335a263c65a8a763d55710718bbdb416000000000000000000000000b85ff091342e2e7a7461238796d5224fa81ca556000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000", replacement_chainid="0x000000000000000000000000000000000000000000000000000000000000814d" }]
+
 
 # BSC Mainnet
 # [[chain_configs]]

bridge-validators/src/block.rs

@@ -112,7 +112,11 @@ impl ChainClient {
                             }
                             if matches {
                                 info!("Event matches; pushing for transit");
-                                result.push(log);
+                                if let Some(v) = self.except.transform_log(&log) {
+                                    result.push(v);
+                                } else {
+                                    info!("Log {log:?} could not be sent for transit due transform_log() failure");
+                                }
                             }
                         }
                     } else {
@@ -202,6 +206,7 @@ impl BlockPolling for ChainClient {
 
         let events: Vec<D> = logs
             .into_iter()
+            .filter_map(|log| self.except.transform_log(&log))
             .map(|log| Ok(parse_log::<D>(log)?))
             .collect::<Result<Vec<D>>>()?;
 
@@ -311,7 +316,7 @@ impl<D: EthEvent> EventListener<D> {
             let mut interval = interval(Duration::from_secs(3));
             // Set this down 1 because we (almost) certainly haven't scanned this block
             // yet...
-            self.current_block = self.chain_client.client.get_block_number().await? - 1;
+            self.current_block = self.get_block_number().await? - 1;
 
             loop {
                 interval.tick().await;

bridge-validators/src/bridge_node.rs

@@ -86,6 +86,14 @@ impl BridgeNode {
     }
 
     pub async fn sync_historic_events(&mut self) -> Result<()> {
+        if self.chain_client.chain_gateway_block_deployed == 0 {
+            warn!(
+                "block_deployed=0 , so not synchronising historic events for chain id {}",
+                self.chain_client.chain_id
+            );
+            return Ok(());
+        }
+
         let max_block_specifier = if self.chain_client.block_instant_finality {
             BlockNumber::Latest
         } else {
@@ -103,7 +111,7 @@ impl BridgeNode {
         let to_block_number = if let Some(v) = self.chain_client.to_block_number {
             if v > finalized_block_number.as_u64() {
                 warn!("to_block in config file {} was greater than latest finalized block {} - will terminate at {}",
-                      v, finalized_block_number, v);
+                      v, finalized_block_number, finalized_block_number);
             }
             std::cmp::min(v, finalized_block_number.as_u64())
         } else {
@@ -305,7 +313,7 @@ impl BridgeNode {
         };
 
         if !self.validators.contains(&address) {
-            info!("Address not part of the validator set, {}", address);
+            info!("Address not part of the validator set, {:x}", address);
             return Ok(());
         }
 

bridge-validators/src/client.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::{ChainGateway, ValidatorManager};
+use crate::{exceptions, ChainGateway, ValidatorManager};
 use anyhow::Result;
 use ethers::{
     middleware::{MiddlewareBuilder, NonceManagerMiddleware, SignerMiddleware},
@@ -33,10 +33,13 @@ pub struct ChainClient {
     pub wallet: LocalWallet,
     pub chain_gateway_block_deployed: u64,
     pub block_instant_finality: bool,
-    pub legacy_gas_estimation_percent: Option<u64>,
+    pub gas_estimation_percent: Option<u64>,
+    pub use_legacy_transactions: bool,
     pub scan_behind_blocks: u64,
     pub log_strategy: LogStrategy,
     pub to_block_number: Option<u64>,
+    pub priority_fee_per_gas_max: Option<u64>,
+    pub except: exceptions::ExceptionProcessor,
 }
 
 impl fmt::Display for ChainClient {
@@ -102,10 +105,13 @@ impl ChainClient {
             wallet,
             chain_gateway_block_deployed: config.chain_gateway_block_deployed,
             block_instant_finality: config.block_instant_finality.unwrap_or_default(),
-            legacy_gas_estimation_percent: config.legacy_gas_estimation_percent,
+            gas_estimation_percent: config.gas_estimation_percent,
+            use_legacy_transactions: config.use_legacy_transactions.unwrap_or(false),
             scan_behind_blocks: config.scan_behind_blocks.unwrap_or_default(),
             log_strategy: strategy,
             to_block_number: config.to_block_number,
+            priority_fee_per_gas_max: config.priority_fee_per_gas_max,
+            except: exceptions::ExceptionProcessor::new(config, chain_id),
         })
     }
 }

bridge-validators/src/exceptions.rs

@@ -0,0 +1,54 @@
+use crate::{ChainConfig, Exception};
+use ethers::types::{Log, H256, U256};
+use std::collections::HashMap;
+use tracing::warn;
+
+/// The exception processor handles exceptions - these are txns which were issued in error, usually as a result
+/// of a bug in the relayer contracts; their parameters are corrected here before being passed on to the rest of
+/// the relayer logic for execution.
+#[derive(Debug, Clone)]
+pub struct ExceptionProcessor {
+    exceptions_by_txnhash: HashMap<H256, Exception>,
+}
+
+impl ExceptionProcessor {
+    pub fn new(config: &ChainConfig, chain_id: U256) -> Self {
+        let mut exceptions_by_txnhash = HashMap::new();
+        config.exceptions.iter().for_each(|v| {
+            v.iter().for_each(|i| {
+                if i.chain_id == chain_id {
+                    exceptions_by_txnhash.insert(i.transaction_id, i.clone());
+                }
+            })
+        });
+        warn!(
+            "Loaded {0} exceptions for chain_id {1}",
+            exceptions_by_txnhash.len(),
+            chain_id
+        );
+        ExceptionProcessor {
+            exceptions_by_txnhash,
+        }
+    }
+
+    // We'll warn!() if we have to drop a log.
+    pub fn transform_log(&self, log: &Log) -> Option<Log> {
+        if let Some(hash) = log.transaction_hash {
+            if let Some(except) = self.exceptions_by_txnhash.get(&hash) {
+                if log
+                    .block_number
+                    .map_or(false, |x| x.as_u64() == except.block_number)
+                    && log.block_hash.map_or(false, |x| x == except.block_hash)
+                    && log.topics.len() == 2
+                {
+                    let mut new_log = log.clone();
+                    new_log.topics[1] = except.replacement_chainid;
+                    new_log.data = except.replacement_bytes.clone();
+                    warn!("Found a match for exception {except:?} with log {log:?} - replacing log data to form {new_log:?}");
+                    return Some(new_log);
+                }
+            }
+        }
+        Some(log.clone())
+    }
+}

bridge-validators/src/main.rs

@@ -3,6 +3,7 @@ mod bridge_node;
 mod client;
 mod crypto;
 mod event;
+mod exceptions;
 mod message;
 mod p2p_node;
 mod signature;
@@ -12,9 +13,14 @@ use std::{fs, path::PathBuf};
 
 use anyhow::Result;
 use clap::Parser;
-use ethers::{contract::abigen, types::Address};
+use ethers::{
+    contract::abigen,
+    types::{Address, Bytes, H256, U256},
+    utils::hex,
+};
 use libp2p::{Multiaddr, PeerId};
 use serde::Deserialize;
+use serde::{de::Error, Deserializer};
 use tracing::info;
 use tracing_subscriber::EnvFilter;
 use validator_node::ValidatorNodeConfig;
@@ -24,17 +30,40 @@ use crate::{crypto::SecretKey, p2p_node::P2pNode};
 abigen!(ChainGateway, "abi/ChainGateway.json",);
 abigen!(ValidatorManager, "abi/ValidatorManager.json");
 
+#[derive(Debug, Clone, Deserialize)]
+pub struct Exception {
+    pub transaction_id: H256,
+    pub block_hash: H256,
+    pub block_number: u64,
+    pub chain_id: U256,
+    #[serde(deserialize_with = "from_hex")]
+    pub replacement_bytes: Bytes,
+    pub replacement_chainid: H256,
+}
+
+fn from_hex<'de, D>(deserializer: D) -> Result<Bytes, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s: String = Deserialize::deserialize(deserializer)?;
+    let some_bytes = hex::decode(s).map_err(D::Error::custom)?;
+    Ok(Bytes::from(some_bytes))
+}
+
 #[derive(Debug, Clone, Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct ChainConfig {
     pub rpc_url: String,
     pub chain_gateway_address: Address,
     pub chain_gateway_block_deployed: u64,
     pub block_instant_finality: Option<bool>,
-    pub legacy_gas_estimation_percent: Option<u64>,
+    pub gas_estimation_percent: Option<u64>,
+    pub use_legacy_transactions: Option<bool>,
     pub scan_behind_blocks: Option<u64>,
     pub use_get_transactions: Option<bool>,
     pub to_block_number: Option<u64>,
+    pub priority_fee_per_gas_max: Option<u64>,
+    pub exceptions: Option<Vec<Exception>>,
 }
 
 #[derive(Debug, Clone, Deserialize)]