Make FaultDisputeGameConfig into ClientState

Author: Naohiro Yoshida

light-client/src/client.rs

@@ -286,7 +286,9 @@ mod test {
     use light_client::{ClientReader, HostClientReader, HostContext, LightClient};
     use optimism_ibc_proto::ibc::lightclients::optimism::v1::ClientState as RawClientState;
     use optimism_ibc_proto::ibc::lightclients::optimism::v1::ConsensusState as RawConsensusState;
+    use optimism_ibc_proto::ibc::lightclients::optimism::v1::FaultDisputeGameConfig as RawFaultDisputeGameConfig;
     use prost::Message;
+
     extern crate std;
 
     struct MockClientReader {
@@ -352,6 +354,11 @@ mod test {
                 frozen: false,
                 rollup_config: Default::default(),
                 l1_config: get_l1_config(),
+                fault_dispute_game_config:  RawFaultDisputeGameConfig {
+                    dispute_game_factory_target_storage_slot: 103,
+                    fault_dispute_game_status_slot: 0,
+                    fault_dispute_game_status_slot_offset: 15,
+                }.into()
             }
         }
     }
@@ -374,7 +381,8 @@ mod test {
         // All the test parameters are created by optimism-ibc-relay-prover#prover_test.go#TestSetupHeadersForUpdateShort
         let raw_cs = hex!("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");
         let raw_cons_state = hex!("0a20000000000000000000000000000000000000000000000000000000000000000010dbfed1c1061a20b3fd51901751662f8d04bba30c658819044aa4b72ede44ea84501028f7b420bd2080252a308582bbad3f9eee79addd939370c7241ee96d425c6a5d6e7fb89e59ad117c38e62064e56821b77b26353be13b86d6a66c32309325339b023fc50bc744ef7fdd824b7b5bc9315244bb0b39914dec4b902c906f064b9c913de3c16a4a505ca75f5bff2f38e5fdd1c106");
-        let raw_cs = RawClientState::decode(raw_cs.as_slice()).unwrap();
+        let mut raw_cs = RawClientState::decode(raw_cs.as_slice()).unwrap();
+        raw_cs.fault_dispute_game_config = Some(ClientState::default().fault_dispute_game_config.into());
         let raw_cons_state = RawConsensusState::decode(raw_cons_state.as_slice()).unwrap();
         let cs = ClientState::try_from(raw_cs).unwrap();
         let cons_state = ConsensusState::try_from(raw_cons_state).unwrap();

light-client/src/client_state.rs

@@ -3,7 +3,7 @@ use crate::errors::Error;
 use crate::header::Header;
 use crate::l1;
 use crate::l1::{L1Config, L1Consensus, L1SyncCommittee};
-use crate::misbehaviour::Misbehaviour;
+use crate::misbehaviour::{FaultDisputeGameConfig, Misbehaviour};
 use crate::misc::{
     new_timestamp, validate_header_timestamp_not_future,
     validate_state_timestamp_within_trusting_period,
@@ -46,6 +46,9 @@ pub struct ClientState {
 
     /// L1 Config
     pub l1_config: L1Config,
+
+    /// Fault Dispute Game Config
+    pub fault_dispute_game_config: FaultDisputeGameConfig,
 }
 
 impl ClientState {
@@ -147,6 +150,7 @@ impl ClientState {
             Misbehaviour::L2(l2) => l2.verify(
                 now.as_unix_timestamp_secs(),
                 &self.l1_config,
+                &self.fault_dispute_game_config,
                 &l1_cons_state,
                 trusted_consensus_state.output_root,
             ),
@@ -332,6 +336,7 @@ impl TryFrom<RawClientState> for ClientState {
 
         let l1_config = value.l1_config.ok_or(Error::MissingL1Config)?;
         let l1_config = L1Config::try_from(l1_config)?;
+        let fault_dispute_game_config = value.fault_dispute_game_config.ok_or(Error::MissingFaultDisputeGameConfig)?;
 
         Ok(Self {
             chain_id: value.chain_id,
@@ -341,6 +346,7 @@ impl TryFrom<RawClientState> for ClientState {
             frozen,
             rollup_config,
             l1_config,
+            fault_dispute_game_config: fault_dispute_game_config.into()
         })
     }
 }
@@ -361,6 +367,7 @@ impl TryFrom<ClientState> for RawClientState {
             rollup_config_json: serde_json::to_vec(&value.rollup_config)
                 .map_err(Error::UnexpectedRollupConfig)?,
             l1_config: Some(value.l1_config.into()),
+            fault_dispute_game_config: Some(value.fault_dispute_game_config.into()),
         })
     }
 }

light-client/src/errors.rs

@@ -70,6 +70,8 @@ pub enum Error {
     // Update
     #[error("MissingL1Config")]
     MissingL1Config,
+    #[error("MissingFaultDisputeGameConfig")]
+    MissingFaultDisputeGameConfig,
     #[error("MissingForkSpec")]
     MissingForkSpec,
     #[error("MissingL1Head")]

light-client/src/misbehaviour.rs

@@ -1,7 +1,6 @@
 use crate::account::AccountUpdateInfo;
 use crate::commitment::decode_eip1184_rlp_proof;
 use crate::errors::Error;
-use crate::header::OPTIMISM_HEADER_TYPE_URL;
 use crate::l1::{L1Config, L1Consensus, L1Header, Misbehaviour as L1Misbehaviour};
 use alloc::vec::Vec;
 use alloy_consensus::Header;
@@ -15,17 +14,9 @@ use kona_protocol::{OutputRoot, Predeploys};
 use light_client::types::ClientId;
 use optimism_ibc_proto::google::protobuf::Any as IBCAny;
 use optimism_ibc_proto::ibc::lightclients::optimism::v1::Misbehaviour as RawL2Misbehaviour;
+use optimism_ibc_proto::ibc::lightclients::optimism::v1::FaultDisputeGameConfig as RawFaultDisputeGameConfig;
 use prost::Message;
 
-/// Confirmed slot of DisputeGameFactoryProxy contract by forge
-const DISPUTE_GAME_FACTORY_STORAGE_SLOT: u64 = 103;
-
-/// storage layout of forge is reverse position
-/// created_at offset = 0, bytes = 8 -> [24:32]
-/// resoled_at offset = 8, bytes = 8 -> [16:23]
-/// status offset = 16, bytes = 1 -> [15]
-const FAULT_DISPUTE_GAME_STATUS_SLOT: u8 = 0;
-const FAULT_DISPUTE_GAME_STATUS_OFFSET: u8 = 15;
 
 const STATUS_DEFENDER_WIN: u8 = 2;
 
@@ -41,13 +32,13 @@ fn calculate_mapping_slot_bytes(key_bytes: &[u8], mapping_slot: u64) -> B256 {
     keccak256(&concatenated)
 }
 
-fn calc_game_uuid(l2_block_num: B256, output_root: B256) -> B256 {
+fn calc_game_uuid(source_game_type: u64, l2_block_num: B256, output_root: B256) -> B256 {
     // Define constants
     // We can split this into words that are 32 bytes long to get:
     // 0000000000000000000000000000000000000000000000000000000000000060  // offset
     // 000000000000000000000000000000000000000000000000000000000000000b  // length
     // 48656c6c6f20576f726c64000000000000000000000000000000000000000000  // extra_data
-    let source_game_type = u64_to_bytes(0);
+    let source_game_type = u64_to_bytes(source_game_type);
     // start position of extra_data length
     // 32 (gameType) + 32(rootClaim) + extraOffset(32)
     let extra_offset = u64_to_bytes(96);
@@ -86,8 +77,35 @@ fn unpack_game_id(game_id: [u8; 32]) -> (Vec<u8>, Vec<u8>, [u8; 20]) {
     (game_type, timestamp, game_proxy)
 }
 
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
+pub struct FaultDisputeGameConfig {
+    dispute_game_factory_target_storage_slot: u32,
+    fault_dispute_game_status_slot: u32,
+    fault_dispute_game_status_slot_offset: u32
+}
+
+impl From<RawFaultDisputeGameConfig> for FaultDisputeGameConfig {
+    fn from(value: RawFaultDisputeGameConfig) -> Self {
+        Self {
+            dispute_game_factory_target_storage_slot: value.dispute_game_factory_target_storage_slot,
+            fault_dispute_game_status_slot: value.fault_dispute_game_status_slot,
+            fault_dispute_game_status_slot_offset: value.fault_dispute_game_status_slot_offset,
+        }
+    }
+}
+
+impl From<FaultDisputeGameConfig> for RawFaultDisputeGameConfig {
+    fn from(value: FaultDisputeGameConfig) -> Self {
+        Self {
+            dispute_game_factory_target_storage_slot: value.dispute_game_factory_target_storage_slot,
+            fault_dispute_game_status_slot: value.fault_dispute_game_status_slot,
+            fault_dispute_game_status_slot_offset: value.fault_dispute_game_status_slot_offset,
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
-struct FaultDisputeGameFactoryProof<const SYNC_COMMITTEE_SIZE: usize> {
+pub struct FaultDisputeGameFactoryProof<const SYNC_COMMITTEE_SIZE: usize> {
     /// Finalized and verified L1 header
     l1_header: L1Header<SYNC_COMMITTEE_SIZE>,
 
@@ -99,6 +117,7 @@ struct FaultDisputeGameFactoryProof<const SYNC_COMMITTEE_SIZE: usize> {
     /// Proof of FaultDisputeGame
     fault_dispute_game_account: AccountUpdateInfo,
     fault_dispute_game_storage_proof: Vec<Vec<u8>>,
+    fault_dispute_game_source_game_type: u64,
 }
 
 impl<const SYNC_COMMITTEE_SIZE: usize> FaultDisputeGameFactoryProof<SYNC_COMMITTEE_SIZE> {
@@ -115,6 +134,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> FaultDisputeGameFactoryProof<SYNC_COMMITT
 
     pub fn verify_resolved_status(
         &self,
+        fault_dispute_game_config: &FaultDisputeGameConfig,
         claimed_l2_number: u64,
         claimed_output_root: B256,
     ) -> Result<(), Error> {
@@ -126,11 +146,12 @@ impl<const SYNC_COMMITTEE_SIZE: usize> FaultDisputeGameFactoryProof<SYNC_COMMITT
 
         // Extract game id from DisputeGameFactoryProxy by output_root.
         let game_uuid = calc_game_uuid(
+            self.fault_dispute_game_source_game_type,
             B256::from(u64_to_bytes(claimed_l2_number)),
             claimed_output_root,
         );
         let game_id_key =
-            calculate_mapping_slot_bytes(game_uuid.as_slice(), DISPUTE_GAME_FACTORY_STORAGE_SLOT);
+            calculate_mapping_slot_bytes(game_uuid.as_slice(), fault_dispute_game_config.dispute_game_factory_target_storage_slot as u64);
         let execution_verifier = ExecutionVerifier;
         let game_id = execution_verifier
             .verify(
@@ -168,8 +189,9 @@ impl<const SYNC_COMMITTEE_SIZE: usize> FaultDisputeGameFactoryProof<SYNC_COMMITT
         let (_, _, fault_dispute_game_address) = unpack_game_id(left_pad(game_id));
         self.fault_dispute_game_account
             .verify_account_storage(&Address(fault_dispute_game_address), state_root)?;
-        let mut status_key = [0u8; 32];
-        status_key[status_key.len() - 1] = FAULT_DISPUTE_GAME_STATUS_SLOT;
+        let status_key = u64_to_bytes(
+            fault_dispute_game_config.fault_dispute_game_status_slot as u64,
+        );
         let execution_verifier = ExecutionVerifier;
         let packing_slot_value = execution_verifier
             .verify(
@@ -194,7 +216,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> FaultDisputeGameFactoryProof<SYNC_COMMITT
             })?;
         let packing_slot_value = left_pad(packing_slot_value);
 
-        let status = packing_slot_value[FAULT_DISPUTE_GAME_STATUS_OFFSET as usize];
+        let status = packing_slot_value[fault_dispute_game_config.fault_dispute_game_status_slot_offset as usize];
         if status != STATUS_DEFENDER_WIN {
             return Err(Error::UnexpectedResolvedStatus {
                 status,
@@ -384,6 +406,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> TryFrom<RawL2Misbehaviour>
             fault_dispute_game_storage_proof: decode_eip1184_rlp_proof(
                 proto_fdg_factory_proof.fault_dispute_game_storage_proof,
             )?,
+            fault_dispute_game_source_game_type: proto_fdg_factory_proof.fault_dispute_game_source_game_type
         };
 
         Ok(Self {
@@ -401,6 +424,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> L2Misbehaviour<SYNC_COMMITTEE_SIZE> {
         &self,
         now: u64,
         l1_config: &L1Config,
+        fault_dispute_game_config: &FaultDisputeGameConfig,
         l1_cons_state: &L1Consensus,
         consensus_output_root: B256,
     ) -> Result<(), Error> {
@@ -427,7 +451,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> L2Misbehaviour<SYNC_COMMITTEE_SIZE> {
 
         // Ensure the status is not defender win
         self.fault_dispute_game_factory_proof
-            .verify_resolved_status(resolved_header.number, self.resolved_output.output_root)?;
+            .verify_resolved_status(fault_dispute_game_config, resolved_header.number, self.resolved_output.output_root)?;
 
         // Misbehaviour detected
         Ok(())
@@ -460,9 +484,7 @@ impl<const SYNC_COMMITTEE_SIZE: usize> TryFrom<IBCAny> for Misbehaviour<SYNC_COM
 mod test {
     use crate::account::AccountUpdateInfo;
     use crate::l1::{ExecutionUpdateInfo, L1Header, TrustedSyncCommittee};
-    use crate::misbehaviour::{
-        FaultDisputeGameFactoryProof, OutputRootWithMessagePasser, TrustedToResolvedL2,
-    };
+    use crate::misbehaviour::{FaultDisputeGameConfig, FaultDisputeGameFactoryProof, OutputRootWithMessagePasser, TrustedToResolvedL2};
     use alloc::vec;
     use alloc::vec::Vec;
     use alloy_consensus::Header;
@@ -481,7 +503,7 @@ mod test {
                     state_root: hex!("84cde1ef1ab57fe978674fe74d94f1c87d6650b908bc85531d791acb80e12f2c").into(),
                     ..Default::default()
                 },
-                timestamp: Time::from_unix_timestamp(100, 0).unwrap()
+                timestamp: Time::from_unix_timestamp(100, 0).unwrap(),
             },
             dispute_game_factory_address: Address(hex!("05F9613aDB30026FFd634f38e5C4dFd30a197Fa1")),
             dispute_game_factory_account: AccountUpdateInfo {
@@ -522,10 +544,22 @@ mod test {
                 hex!("f9013180a0c52caf0505888b98c4fdb6cc7fb993c8bfa0d2493c4a2232714597de0e30f93ba0224cf7cab9c53845fcc3a8efb965ba1f754331666ada4f5ff00839123de8795480a0c8d8343191741f6635e15c60124fe6139eb6a0bcff26bd218bcea6aa2ba9d5d780a012d5e40264430bdfe8262bff91e0c9e15d05cc04bc25b0521a443a7decc193d1808080a0bc34934c765a0311fe38c14de0885983fe78ac320b7a30ad21c3621df72bb990a097c0d14e0a74999048d691ae25278a957d3874f112a30d6a2b095319d30d4791a03e26c8b1f3ff7d89e6abf24334b82b60f2e583c675e255eea4b73685da72c604a07706734103e02b3cd9d9c12e58e136354b079e21bea41e29c132f7d1e786e87080a087ecc59cde21b3078405d2d5ababfc88072c75d0ad6fca7dabde42dac0b6913080").into(),
                 hex!("f851808080808080808080a0fddbf730157e6bcd58316bf1fb2efa39acffbdb43f6e3207481dfd601a08d4958080808080a020de6edcfdb3b33776c67bfd5d7e6ec0ce7045ba913627a8cb6db827bcd1f39580").into(),
                 hex!("f5a0200decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e56393920102000000006837d1040000000068333388").into(),
-            ]
+            ],
+            fault_dispute_game_source_game_type: 0
         };
         model
             .verify_resolved_status(
+                &FaultDisputeGameConfig {
+                    // Confirmed slot of DisputeGameFactoryProxy contract by forge
+                    dispute_game_factory_target_storage_slot: 103,
+                    // Confirmed slot of FaultDisputeGame contract by forge
+                    // storage layout of forge is reverse position
+                    // created_at offset = 0, bytes = 8 -> [24:32]
+                    // resoled_at offset = 8, bytes = 8 -> [16:23]
+                    // status offset = 16, bytes = 1 -> [15]
+                    fault_dispute_game_status_slot: 0,
+                    fault_dispute_game_status_slot_offset: 15,
+                },
                 28191582,
                 hex!("f0d512abcee62939dbf802954c5202629e81d7e46423ce86ac789613b5668222").into(),
             )

proto/definitions/ibc/lightclients/optimism/v1/optimism.proto

@@ -24,6 +24,12 @@ message L1Config {
   google.protobuf.Duration max_clock_drift = 10 [(gogoproto.nullable) = false, (gogoproto.stdduration) = true];
 }
 
+message FaultDisputeGameConfig {
+  uint32 dispute_game_factory_target_storage_slot = 1;
+  uint32 fault_dispute_game_status_slot = 2;
+  uint32 fault_dispute_game_status_slot_offset = 3;
+}
+
 message ClientState {
   uint64 chain_id = 1;
 
@@ -37,6 +43,7 @@ message ClientState {
   bytes rollup_config_json = 6;
 
   L1Config l1_config = 7;
+  FaultDisputeGameConfig fault_dispute_game_config = 8;
 
 }
 
@@ -88,6 +95,7 @@ message FaultDisputeGameFactoryProof {
 
   AccountUpdate fault_dispute_game_account = 5;
   bytes fault_dispute_game_storage_proof = 6;
+  uint64 fault_dispute_game_source_game_type = 7;
 }
 
 message OutputRootWithMessagePasser {

proto/src/prost/ibc.lightclients.optimism.v1.rs

@@ -30,6 +30,16 @@ pub struct L1Config {
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FaultDisputeGameConfig {
+    #[prost(uint32, tag = "1")]
+    pub dispute_game_factory_target_storage_slot: u32,
+    #[prost(uint32, tag = "2")]
+    pub fault_dispute_game_status_slot: u32,
+    #[prost(uint32, tag = "3")]
+    pub fault_dispute_game_status_slot_offset: u32,
+}
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ClientState {
     #[prost(uint64, tag = "1")]
     pub chain_id: u64,
@@ -47,6 +57,8 @@ pub struct ClientState {
     pub rollup_config_json: ::prost::alloc::vec::Vec<u8>,
     #[prost(message, optional, tag = "7")]
     pub l1_config: ::core::option::Option<L1Config>,
+    #[prost(message, optional, tag = "8")]
+    pub fault_dispute_game_config: ::core::option::Option<FaultDisputeGameConfig>,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
@@ -135,6 +147,8 @@ pub struct FaultDisputeGameFactoryProof {
     pub fault_dispute_game_account: ::core::option::Option<AccountUpdate>,
     #[prost(bytes = "vec", tag = "6")]
     pub fault_dispute_game_storage_proof: ::prost::alloc::vec::Vec<u8>,
+    #[prost(uint64, tag = "7")]
+    pub fault_dispute_game_source_game_type: u64,
 }
 #[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]