feat: updatable validator commissions (#3591)

* feat: updatable validator commissions

- stake table contract: allow updates with rate limits
- migrate commissions from V1 stake table into storage for V2
- handle commission changes in the GCL
- test: stake table state gets invalid commission
- break up some lines to fix cargo fmt
- handle patch upgrades for stake table
- stake table upgrade: dedupe upgrade preparation
- test: unittest commission updates

* fix: mock stake table, initialization for tests

* update Cargo.lock

* fix: solhint

* fix: staking-cli command

* fix: solhint

* fix: clippy, unnnecessary into_iter

I don't understand why this shows up in this branch, but not on main.

* fix: check revert selector

* test: assert assert to check effect

* test: fork test for sepolia stake table upgrade

* fix: commit missing file

* test: commission updates integration test

* cleanup: use new fetch_commission function

* remove half implemented commission tracking

* remove half implemented commission tracking (v2)

* remove half implemented commission tracking (v3)

* address review comments

- More tests for initialization from existing contract.
- Emit previous validator commissions.
- Update staking-cli README.
- Rename Update -> Increase.

* fix compilation: add missing fields

* fix: serde

* test: UpdateCommissions serde rountrip test

* address review comments

- Add no-self-delegation delegator config for easier testing of
  commission change.
- Add CLI test for too early commission updates.
- Add some clarifying comments.

* test: assert other validators receiving rewards

* fixup: remove duplicate

Author: sveitser

Cargo.lock

@@ -103,6 +103,7 @@ alloy = { version = "0.13", default-features = false, features = [
     "rpc",
     "rpc-client",
     "rpc-types",
+    "serde",
     "signer-local",
     "signer-mnemonic",
     "signer-ledger",

Cargo.toml

@@ -23,6 +23,7 @@ ark-ff = { workspace = true }
 ark-poly = { workspace = true }
 ark-serialize = { workspace = true }
 ark-std = { workspace = true }
+derive_more = { workspace = true }
 hotshot-types = { workspace = true }
 jf-pcs = { workspace = true }
 jf-plonk = { workspace = true }
@@ -35,6 +36,7 @@ serde = { workspace = true }
 thiserror = { workspace = true }
 
 [dev-dependencies]
+bincode = { workspace = true }
 tokio = { workspace = true }
 
 [lints]

contracts/rust/adapter/Cargo.toml

@@ -269,8 +269,8 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use self::{
     staketablev2::{EdOnBN254::EdOnBN254Point, BN254::G2Point},
     StakeTableV2::{
-        ConsensusKeysUpdated, ConsensusKeysUpdatedV2, Delegated, Undelegated, ValidatorExit,
-        ValidatorRegistered, ValidatorRegisteredV2,
+        CommissionUpdated, ConsensusKeysUpdated, ConsensusKeysUpdatedV2, Delegated, Undelegated,
+        ValidatorExit, ValidatorRegistered, ValidatorRegisteredV2,
     },
 };
 
@@ -373,6 +373,37 @@ impl<'de> Deserialize<'de> for ValidatorRegisteredV2 {
     }
 }
 
+impl Serialize for CommissionUpdated {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        (
+            &self.validator,
+            self.timestamp,
+            self.oldCommission,
+            self.newCommission,
+        )
+            .serialize(serializer)
+    }
+}
+
+#[allow(non_snake_case)]
+impl<'de> Deserialize<'de> for CommissionUpdated {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (validator, timestamp, oldCommission, newCommission) = <_>::deserialize(deserializer)?;
+        Ok(Self {
+            validator,
+            timestamp,
+            newCommission,
+            oldCommission,
+        })
+    }
+}
+
 impl Serialize for EdOnBN254Point {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -558,3 +589,29 @@ impl<'de> Deserialize<'de> for ConsensusKeysUpdatedV2 {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use alloy::{primitives::U256, sol_types::private::Address};
+
+    use super::*;
+
+    #[test]
+    fn test_commission_updated_serde_roundtrip() {
+        let original = CommissionUpdated {
+            validator: Address::random(),
+            timestamp: U256::from(999),
+            oldCommission: 123,
+            newCommission: 456,
+        };
+
+        let serialized = bincode::serialize(&original).expect("Failed to serialize");
+        let deserialized: CommissionUpdated =
+            bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+        assert_eq!(original.validator, deserialized.validator);
+        assert_eq!(original.timestamp, deserialized.timestamp);
+        assert_eq!(original.oldCommission, deserialized.oldCommission);
+        assert_eq!(original.newCommission, deserialized.newCommission);
+    }
+}

contracts/rust/adapter/src/bindings/staketablev2.rs

@@ -200,6 +200,15 @@ impl ConsensusKeysUpdatedV2 {
     }
 }
 
+impl From<StakeTable::ValidatorRegistered> for StakeTableV2::InitialCommission {
+    fn from(value: StakeTable::ValidatorRegistered) -> Self {
+        Self {
+            validator: value.account,
+            commission: value.commission,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use alloy::primitives::Address;

contracts/rust/adapter/src/sol_types.rs

@@ -23,6 +23,7 @@ tracing = "0.1.37"
 vbs = { workspace = true }
 
 [dev-dependencies]
+rand = { workspace = true }
 sequencer-utils = { version = "0.1.0", path = "../../../utils" }
 test-log = { workspace = true }
 

contracts/rust/adapter/src/stake_table.rs

@@ -0,0 +1,67 @@
+use alloy::{
+    network::{Network, TransactionBuilder},
+    primitives::Address,
+    providers::{
+        fillers::{FillerControlFlow, TxFiller},
+        Provider, SendableTx,
+    },
+    transports::TransportResult,
+};
+
+/// A filler that sets the `from` field on transactions to impersonate a specific address.
+/// This is useful when using Anvil's impersonation features to send transactions from
+/// accounts that we don't have the private key for.
+///
+/// Avoids having to manually set the `from` field on transactions.
+#[derive(Clone, Debug, Default)]
+pub struct ImpersonateFiller {
+    from: Address,
+}
+
+impl ImpersonateFiller {
+    pub fn new(from: Address) -> Self {
+        Self { from }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ImpersonateFillable {
+    pub from: Address,
+}
+
+impl<N: Network> TxFiller<N> for ImpersonateFiller {
+    type Fillable = ImpersonateFillable;
+
+    fn status(&self, tx: &N::TransactionRequest) -> FillerControlFlow {
+        if tx.from().is_none() {
+            FillerControlFlow::Ready
+        } else {
+            FillerControlFlow::Finished
+        }
+    }
+
+    async fn prepare<P: Provider<N>>(
+        &self,
+        _provider: &P,
+        _tx: &N::TransactionRequest,
+    ) -> TransportResult<Self::Fillable> {
+        Ok(ImpersonateFillable { from: self.from })
+    }
+
+    async fn fill(
+        &self,
+        fillable: Self::Fillable,
+        mut tx: SendableTx<N>,
+    ) -> TransportResult<SendableTx<N>> {
+        if let Some(builder) = tx.as_mut_builder() {
+            builder.set_from(fillable.from);
+        }
+        Ok(tx)
+    }
+
+    fn fill_sync(&self, tx: &mut SendableTx<N>) {
+        if let Some(builder) = tx.as_mut_builder() {
+            builder.set_from(self.from);
+        }
+    }
+}