Chain state module

Cargo.toml

@@ -21,8 +21,10 @@ members = [
     "module-system/sov-modules-api",
     "module-system/module-schemas",
     "module-system/utils/sov-first-read-last-write-cache",
+    "module-system/utils/sov-data-generators",
     "module-system/module-implementations/sov-accounts",
     "module-system/module-implementations/sov-bank",
+    "module-system/module-implementations/sov-chain-state", 
     "module-system/module-implementations/sov-blob-storage",
     "module-system/module-implementations/sov-evm",
     "module-system/module-implementations/sov-prover-incentives",
@@ -48,7 +50,8 @@ rust-version = "1.66"
 
 [workspace.dependencies]
 # Dependencies maintained by sovereign
-jmt = "0.6.0"
+# TODO: replace by release number once available on crates.io: tracking issue https://github.com/Sovereign-Labs/sovereign-sdk/issues/632
+jmt = { git = "https://github.com/penumbra-zone/jmt", commit = "46b4b00" }
 
 # External dependencies
 async-trait = "0.1.71"

adapters/celestia/src/celestia.rs

@@ -11,6 +11,7 @@ use prost::bytes::Buf;
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use sov_rollup_interface::da::{BlockHeaderTrait as BlockHeader, CountedBufReader};
+use sov_rollup_interface::services::da::SlotData;
 use sov_rollup_interface::AddressTrait;
 pub use tendermint::block::Header as TendermintHeader;
 use tendermint::block::Height;
@@ -29,7 +30,7 @@ use crate::pfb::{BlobTx, MsgPayForBlobs, Tx};
 use crate::shares::{read_varint, BlobIterator, BlobRefIterator, NamespaceGroup};
 use crate::utils::BoxError;
 use crate::verifier::address::CelestiaAddress;
-use crate::verifier::{TmHash, PFB_NAMESPACE};
+use crate::verifier::{ChainValidityCondition, TmHash, PFB_NAMESPACE};
 
 #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
 pub struct MarshalledDataAvailabilityHeader {
@@ -303,6 +304,30 @@ impl BlockHeader for CelestiaHeader {
     }
 }
 
+/// We implement [`SlotData`] for [`CelestiaHeader`] in a similar fashion as for [`FilteredCelestiaBlock`]
+impl SlotData for CelestiaHeader {
+    type BlockHeader = CelestiaHeader;
+    type Cond = ChainValidityCondition;
+
+    fn hash(&self) -> [u8; 32] {
+        match self.header.hash() {
+            tendermint::Hash::Sha256(h) => h,
+            tendermint::Hash::None => unreachable!("tendermint::Hash::None should not be possible"),
+        }
+    }
+
+    fn header(&self) -> &Self::BlockHeader {
+        self
+    }
+
+    fn validity_condition(&self) -> ChainValidityCondition {
+        ChainValidityCondition {
+            prev_hash: *self.header().prev_hash().inner(),
+            block_hash: <Self as SlotData>::hash(self),
+        }
+    }
+}
+
 #[derive(Deserialize, Serialize, PartialEq, Debug, Clone)]
 pub struct CelestiaVersion {
     pub block: u32,

adapters/celestia/src/types.rs

@@ -6,6 +6,7 @@ use base64::Engine;
 use borsh::{BorshDeserialize, BorshSerialize};
 pub use nmt_rs::NamespaceId;
 use serde::{Deserialize, Serialize};
+use sov_rollup_interface::da::BlockHeaderTrait;
 use sov_rollup_interface::services::da::SlotData;
 use sov_rollup_interface::Bytes;
 use tendermint::crypto::default::Sha256;
@@ -14,7 +15,7 @@ use tendermint::merkle;
 use crate::pfb::MsgPayForBlobs;
 use crate::shares::{NamespaceGroup, Share};
 use crate::utils::BoxError;
-use crate::verifier::PARITY_SHARES_NAMESPACE;
+use crate::verifier::{ChainValidityCondition, PARITY_SHARES_NAMESPACE};
 use crate::{CelestiaHeader, TxPosition};
 
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
@@ -81,6 +82,7 @@ pub struct FilteredCelestiaBlock {
 
 impl SlotData for FilteredCelestiaBlock {
     type BlockHeader = CelestiaHeader;
+    type Cond = ChainValidityCondition;
 
     fn hash(&self) -> [u8; 32] {
         match self.header.header.hash() {
@@ -92,6 +94,13 @@ impl SlotData for FilteredCelestiaBlock {
     fn header(&self) -> &Self::BlockHeader {
         &self.header
     }
+
+    fn validity_condition(&self) -> ChainValidityCondition {
+        ChainValidityCondition {
+            prev_hash: *self.header().prev_hash().inner(),
+            block_hash: self.hash(),
+        }
+    }
 }
 
 impl FilteredCelestiaBlock {

adapters/celestia/src/verifier/mod.rs

@@ -1,3 +1,4 @@
+use borsh::{BorshDeserialize, BorshSerialize};
 use nmt_rs::NamespaceId;
 use serde::{Deserialize, Serialize};
 use sov_rollup_interface::da::{
@@ -97,14 +98,27 @@ impl DaSpec for CelestiaSpec {
     type CompletenessProof = Vec<RelevantRowProof>;
 
     type ChainParams = RollupParams;
+
+    type ValidityCondition = ChainValidityCondition;
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct RollupParams {
     pub namespace: NamespaceId,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Serialize,
+    Deserialize,
+    Hash,
+    BorshDeserialize,
+    BorshSerialize,
+)]
 /// A validity condition expressing that a chain of DA layer blocks is contiguous and canonical
 pub struct ChainValidityCondition {
     pub prev_hash: [u8; 32],
@@ -131,8 +145,6 @@ impl da::DaVerifier for CelestiaVerifier {
 
     type Error = ValidationError;
 
-    type ValidityCondition = ChainValidityCondition;
-
     fn new(params: <Self::Spec as DaSpec>::ChainParams) -> Self {
         Self {
             rollup_namespace: params.namespace,
@@ -145,7 +157,7 @@ impl da::DaVerifier for CelestiaVerifier {
         txs: &[<Self::Spec as DaSpec>::BlobTransaction],
         inclusion_proof: <Self::Spec as DaSpec>::InclusionMultiProof,
         completeness_proof: <Self::Spec as DaSpec>::CompletenessProof,
-    ) -> Result<Self::ValidityCondition, Self::Error> {
+    ) -> Result<<Self::Spec as DaSpec>::ValidityCondition, Self::Error> {
         // Validate that the provided DAH is well-formed
         block_header.validate_dah()?;
         let validity_condition = ChainValidityCondition {

adapters/risc0/src/guest.rs

@@ -1,6 +1,7 @@
 #[cfg(target_os = "zkvm")]
 use risc0_zkvm::guest::env;
 use sov_rollup_interface::zk::{Zkvm, ZkvmGuest};
+use sov_rollup_interface::AddressTrait;
 
 use crate::Risc0MethodId;
 
@@ -37,7 +38,18 @@ impl Zkvm for Risc0Guest {
         _serialized_proof: &'a [u8],
         _code_commitment: &Self::CodeCommitment,
     ) -> Result<&'a [u8], Self::Error> {
-        // Implement this method once risc0 supports recursion
-        todo!()
+        // Implement this method once risc0 supports recursion: issue #633
+        todo!("Implement once risc0 supports recursion")
+    }
+
+    fn verify_and_extract_output<
+        C: sov_rollup_interface::zk::ValidityCondition,
+        Add: AddressTrait,
+    >(
+        _serialized_proof: &[u8],
+        _code_commitment: &Self::CodeCommitment,
+    ) -> Result<sov_rollup_interface::zk::StateTransition<C, Add>, Self::Error> {
+        // Implement this method once risc0 supports recursion: issue https://github.com/Sovereign-Labs/sovereign-sdk/issues/633
+        todo!("Implement once risc0 supports recursion: https://github.com/Sovereign-Labs/sovereign-sdk/issues/633")
     }
 }

adapters/risc0/src/host.rs

@@ -6,6 +6,7 @@ use risc0_zkvm::{
     Executor, ExecutorEnvBuilder, LocalExecutor, SegmentReceipt, Session, SessionReceipt,
 };
 use sov_rollup_interface::zk::{Zkvm, ZkvmHost};
+use sov_rollup_interface::AddressTrait;
 
 use crate::Risc0MethodId;
 
@@ -55,6 +56,16 @@ impl<'prover> Zkvm for Risc0Host<'prover> {
     ) -> Result<&'a [u8], Self::Error> {
         verify_from_slice(serialized_proof, code_commitment)
     }
+
+    fn verify_and_extract_output<
+        C: sov_rollup_interface::zk::ValidityCondition,
+        Add: AddressTrait,
+    >(
+        _serialized_proof: &[u8],
+        _code_commitment: &Self::CodeCommitment,
+    ) -> Result<sov_rollup_interface::zk::StateTransition<C, Add>, Self::Error> {
+        todo!("Implement once risc0 supports recursion, issue https://github.com/Sovereign-Labs/sovereign-sdk/issues/633")
+    }
 }
 
 pub struct Risc0Verifier;
@@ -70,6 +81,18 @@ impl Zkvm for Risc0Verifier {
     ) -> Result<&'a [u8], Self::Error> {
         verify_from_slice(serialized_proof, code_commitment)
     }
+
+    fn verify_and_extract_output<
+        C: sov_rollup_interface::zk::ValidityCondition,
+        Add: AddressTrait,
+    >(
+        _serialized_proof: &[u8],
+        _code_commitment: &Self::CodeCommitment,
+    ) -> Result<sov_rollup_interface::zk::StateTransition<C, Add>, Self::Error> {
+        // Method to implement: not clear how to deserialize the proof output.
+        // Issue https://github.com/Sovereign-Labs/sovereign-sdk/issues/621
+        todo!("not clear how to deserialize the proof output. Issue https://github.com/Sovereign-Labs/sovereign-sdk/issues/621")
+    }
 }
 
 fn verify_from_slice<'a>(

examples/demo-nft-module/Cargo.toml

@@ -19,6 +19,7 @@ sov-state = { path = "../../module-system/sov-state", default-features = false }
 
 [dev-dependencies]
 sov-rollup-interface = { path = "../../rollup-interface" }
+sov-data-generators = { path = "../../module-system/utils/sov-data-generators" }
 tempfile = { workspace = true }