offchain processing macro and example for sov-nft-module

Cargo.toml

@@ -18,7 +18,9 @@ members = [
 
     "utils/zk-cycle-macros",
     "utils/zk-cycle-utils",
+    "utils/nft-utils",
     "utils/bashtestmd",
+    "utils/nft-utils",
 
     "module-system/sov-cli",
     "module-system/sov-modules-stf-template",

examples/demo-rollup/Cargo.toml

@@ -79,7 +79,7 @@ native = ["anyhow", "jsonrpsee", "serde", "serde_json", "tracing", "tokio", "tra
 	"sov-state/native", "sov-cli", "clap", "sov-celestia-adapter/native", "sov-db", "sov-sequencer", "sov-stf-runner/native",
 	"sov-modules-api/native", "sov-rollup-interface/native"]
 bench = ["native", "async-trait", "borsh", "hex"]
-
+offchain = ["demo-stf/offchain"]
 
 [[bench]]
 name = "rollup_bench"

examples/demo-stf/Cargo.toml

@@ -51,6 +51,7 @@ rand = "0.8"
 
 [features]
 default = []
+offchain = ["sov-nft-module/offchain"]
 experimental = ["sov-evm/experimental", "reth-primitives"]
 native = [
     "sov-stf-runner/native",

full-node/sov-sequencer/src/utils.rs

@@ -38,6 +38,39 @@ impl SimpleClient {
         Ok(())
     }
 
+    /// Sends multiple transactions to the sequencer for immediate publication.
+    pub async fn send_transactions<Tx: BorshSerialize>(
+        &self,
+        txs: Vec<Tx>,
+        chunk_size: Option<usize>,
+    ) -> Result<(), anyhow::Error> {
+        let serialized_txs: Vec<Vec<u8>> = txs
+            .into_iter()
+            .map(|tx| tx.try_to_vec())
+            .collect::<Result<_, _>>()?;
+
+        match chunk_size {
+            Some(batch_size) => {
+                for chunk in serialized_txs.chunks(batch_size) {
+                    let response: String = self
+                        .http_client
+                        .request("sequencer_publishBatch", chunk.to_vec())
+                        .await?;
+                    info!("publish batch response for chunk: {:?}", response);
+                }
+            }
+            None => {
+                let response: String = self
+                    .http_client
+                    .request("sequencer_publishBatch", serialized_txs)
+                    .await?;
+                info!("publish batch response: {:?}", response);
+            }
+        }
+
+        Ok(())
+    }
+
     /// Get a reference to the underlying [`HttpClient`]
     pub fn http(&self) -> &HttpClient {
         &self.http_client

full-node/sov-stf-runner/src/batch_builder.rs

@@ -125,14 +125,14 @@ where
             current_batch_size += tx_len;
         }
 
-        if txs.is_empty() {
-            bail!("No valid transactions are available");
-        }
-
         for (tx, err) in dismissed {
             warn!("Transaction 0x{} was dismissed: {:?}", hex::encode(tx), err);
         }
 
+        if txs.is_empty() {
+            bail!("No valid transactions are available");
+        }
+
         Ok(txs)
     }
 }

module-system/module-implementations/sov-nft-module/Cargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "sov-nft-module"
+description = "A Sovereign SDK module for managing non-fungible tokens"
 version = { workspace = true }
 edition = { workspace = true }
 authors = { workspace = true }
@@ -21,6 +22,10 @@ sov-modules-api = { path = "../../sov-modules-api" }
 sov-modules-macros = {path = "../../sov-modules-macros"}
 sov-state = { path = "../../sov-state" }
 
+postgres = { version = "0.19.7", optional = true }
+tokio = { version = "1.32.0", features=["full"], optional = true }
+tracing = { workspace = true, optional = true }
+
 [dev-dependencies]
 sov-rollup-interface = { path = "../../../rollup-interface" }
 sov-data-generators = { path = "../../utils/sov-data-generators" }
@@ -29,5 +34,6 @@ sov-nft-module = { version = "*", features = ["native"], path = "." }
 
 [features]
 default = []
+offchain = ["postgres","tokio","tracing"]
 native = ["serde_json", "jsonrpsee", "schemars", "sov-state/native", "sov-modules-api/native", ]
 test = ["native"]

module-system/module-implementations/sov-nft-module/offchain_readme.md

@@ -0,0 +1,60 @@
+## Offchain testing
+
+### Introduction
+This readme outlines the steps to demonstrate the offchain processing functionality that is part of the `sov-nft-module`
+
+### Steps
+* Install postgres on your system
+* Start the postgres terminal
+* Create the tables necessary for offchain processing
+
+```bash
+psql postgres -f sovereign/module-system/module-implementations/sov-nft-module/src/init_db.sql
+```
+* The above command runs the `init_db.sql` script which creates 3 tables
+  * `collections` - tracking the NFT collections that have been created, their supply and other info
+  * `nfts` - tracking the individual NFTs, the `token_uri` pointing to offchain state and other info
+    * `top_owners` - tracks the number of NFTs of each collection that a user owns
+      * running the following query can show the top owners for a specific collection
+      ```sql
+      SELECT owner, count 
+        FROM top_owners
+        WHERE collection_address = (
+          SELECT collection_address
+          FROM collections
+          WHERE collection_name = 'your_collection_name'
+        )
+        ORDER BY count DESC
+        LIMIT 5;
+      ```
+      * running the following query can show the largest owner for each collection
+      ```sql
+      SELECT
+        collection_name,
+        owner,
+        count
+      FROM (
+          SELECT c.collection_name, t.owner, t.count,
+          RANK() OVER (PARTITION BY t.collection_address ORDER BY t.count DESC) as rank
+          FROM top_owners t
+          INNER JOIN collections c ON c.collection_address = t.collection_address
+      ) sub
+      WHERE rank = 1;
+      ```        
+
+* Run the demo rollup in offchain mode
+```bash
+rm -rf demo_data; POSTGRES_CONNECTION_STRING="postgresql://username:password@localhost/postgres" cargo run --features offchain -- --da-layer mock
+```
+* Explanation of the above command
+  * `rm -rf demo_data` is to wipe the rollup state. For testing its better to start with clean state
+  * `POSTGRES_CONNECTION_STRING` is to allow the offchain component of the `sov-nft-module` to connect to postgres instance
+  * `--features offchain` is necessary to enable offchain processing. Without the feature, the functions are no-ops
+  * `--da-layer mock` is used to run an in-memory local DA layer
+* Run the NFT minting script
+```bash
+$ cd sovereign/utils/nft-utils
+$ cargo run
+```
+  * The above script creates 3 NFT collections, mints some NFTs to each collection
+  * The tables can be explored by connecting to postgres and running sample queries from above