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/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 Condition = 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")
     }
 }

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 #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 }
 
 

examples/demo-nft-module/tests/nft_test.rs

@@ -2,7 +2,7 @@ use demo_nft_module::call::CallMessage;
 use demo_nft_module::query::OwnerResponse;
 use demo_nft_module::{NonFungibleToken, NonFungibleTokenConfig};
 use sov_modules_api::default_context::DefaultContext;
-use sov_modules_api::test_utils::generate_address as gen_addr_generic;
+use sov_modules_api::utils::generate_address as gen_addr_generic;
 use sov_modules_api::{Address, Context, Module};
 use sov_rollup_interface::stf::Event;
 use sov_state::{DefaultStorageSpec, ProverStorage, WorkingSet};
@@ -21,7 +21,7 @@ fn genesis_and_mint() {
     let owner2 = generate_address("owner2");
     let config: NonFungibleTokenConfig<C> = NonFungibleTokenConfig {
         admin,
-        owners: vec![(0, owner1.clone())],
+        owners: vec![(0, owner1)],
     };
 
     let tmpdir = tempfile::tempdir().unwrap();
@@ -40,7 +40,7 @@ fn genesis_and_mint() {
 
     // Mint, anybody can mint
     let mint_message = CallMessage::Mint { id: 1 };
-    let owner2_context = C::new(owner2.clone());
+    let owner2_context = C::new(owner2);
     nft.call(mint_message.clone(), &owner2_context, &mut working_set)
         .expect("Minting failed");
 
@@ -63,23 +63,20 @@ fn genesis_and_mint() {
 fn transfer() {
     // Preparation
     let admin = generate_address("admin");
-    let admin_context = C::new(admin.clone());
+    let admin_context = C::new(admin);
     let owner1 = generate_address("owner2");
-    let owner1_context = C::new(owner1.clone());
+    let owner1_context = C::new(owner1);
     let owner2 = generate_address("owner2");
     let config: NonFungibleTokenConfig<C> = NonFungibleTokenConfig {
-        admin: admin.clone(),
-        owners: vec![(0, admin.clone()), (1, owner1.clone()), (2, owner2.clone())],
+        admin,
+        owners: vec![(0, admin), (1, owner1), (2, owner2)],
     };
     let tmpdir = tempfile::tempdir().unwrap();
     let mut working_set = WorkingSet::new(ProverStorage::with_path(tmpdir.path()).unwrap());
     let nft = NonFungibleToken::default();
     nft.genesis(&config, &mut working_set).unwrap();
 
-    let transfer_message = CallMessage::Transfer {
-        id: 1,
-        to: owner2.clone(),
-    };
+    let transfer_message = CallMessage::Transfer { id: 1, to: owner2 };
 
     // admin cannot transfer token of the owner1
     let transfer_attempt = nft.call(transfer_message.clone(), &admin_context, &mut working_set);
@@ -122,9 +119,9 @@ fn transfer() {
 fn burn() {
     // Preparation
     let admin = generate_address("admin");
-    let admin_context = C::new(admin.clone());
+    let admin_context = C::new(admin);
     let owner1 = generate_address("owner2");
-    let owner1_context = C::new(owner1.clone());
+    let owner1_context = C::new(owner1);
     let config: NonFungibleTokenConfig<C> = NonFungibleTokenConfig {
         admin,
         owners: vec![(0, owner1)],