sugondat-da-adapter: use shim

pepyakin · pepyakin · commit 710b0f928bad · 2023-11-22T11:25:37.000+01:00
this removes all the subxt and substrate cruft from the sovereign
adapter.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/sugondat-da-adapter/Cargo.toml b/sugondat-da-adapter/Cargo.toml
@@ -8,12 +8,8 @@ edition = "2021"
 [dependencies]
 parity-scale-codec = "3.6.3"
 # The only required dependency for a DA adapter is the Sovereign SDK...
-sov-rollup-interface =  { git = "https://github.com/Sovereign-Labs/sovereign-sdk", rev = "6058b31" }
+sov-rollup-interface = { git = "https://github.com/Sovereign-Labs/sovereign-sdk", rev = "6058b31" }
 
-sugondat-subxt = { path = "../sugondat-subxt", optional = true }
-subxt = {version = "0.32.1", optional = true }
-subxt-signer = {version = "0.32.1", optional = true, features = ["subxt"] }
-sp-keyring = { git = "https://github.com/paritytech/polkadot-sdk", optional = true, default-features = false, branch = "release-polkadot-v1.2.0" }
 tracing = "0.1.37"
 serde = { version = "1", features = ["derive"] }
 hex = { version = "0.4.3", features = ["serde"] }
@@ -25,13 +21,23 @@ bytes = { version = "1", features = ["serde"] }
 
 sha2 = { version = "0.10.6", default-features = false }
 sugondat-nmt = { path = "../sugondat-nmt", default-features = false }
-
+jsonrpsee = { version = "0.20.3", optional = true, features = ["ws-client"] }
+tokio = { version = "1", optional = true }
+sugondat-shim-common-sovereign = { path = "../sugondat-shim/common/sovereign", optional = true, default-features = false, features = [
+    "client",
+] }
 anyhow = "1.0.68"
 async-trait = "0.1.71"
-tokio = { version = "1", optional = true }
 digest = "0.10.7"
 
 [features]
 default = ["native"]
-native = ["sov-rollup-interface/native", "sugondat-nmt/serde", "sugondat-nmt/native", "dep:sugondat-subxt", "dep:subxt", "dep:subxt-signer", "dep:sp-keyring", "dep:tokio"]
+native = [
+    "sov-rollup-interface/native",
+    "sugondat-nmt/serde",
+    "sugondat-nmt/native",
+    "dep:tokio",
+    "dep:jsonrpsee",
+    "dep:sugondat-shim-common-sovereign",
+]
 verifier = ["sugondat-nmt/serde"]
diff --git a/sugondat-da-adapter/src/service.rs b/sugondat-da-adapter/src/service.rs
@@ -1,22 +1,18 @@
 use crate::{
     spec::{ChainParams, DaLayerSpec},
-    types,
+    types::{self, Hash},
     verifier::SugondatVerifier,
 };
 use async_trait::async_trait;
 use sov_rollup_interface::da::DaSpec;
-
-use subxt::backend::rpc::{rpc_params, RpcClient};
-use sugondat_subxt::sugondat::{
-    runtime_types::bounded_collections::bounded_vec::BoundedVec, storage,
-};
+use sugondat_shim_common_sovereign::SovereignRPCClient;
 
 mod client;
 
 use client::Client;
 
 fn default_rpc_addr() -> String {
-    "ws://localhost:9988/".into()
+    "ws://localhost:10995/".into()
 }
 
 /// Runtime configuration for the DA service
@@ -54,119 +50,25 @@ impl sov_rollup_interface::services::da::DaService for DaProvider {
     // Make an RPC call to the node to get the finalized block at the given height, if one exists.
     // If no such block exists, block until one does.
     async fn get_finalized_at(&self, height: u64) -> Result<Self::FilteredBlock, Self::Error> {
-        let client = self.client.clone();
-        let namespace = self.namespace;
-        let client_url = client.url().await;
-        let client = client.client().await?;
-
-        loop {
-            let finalized_head = client.backend().latest_finalized_block_ref().await?;
-            let header = client
-                .backend()
-                .block_header(finalized_head.hash())
-                .await?
-                .unwrap();
-            if header.number as u64 >= height {
-                break;
-            }
-            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-        }
-
-        // between version 0.29 and 0.32 they remove subxt::rpc::Rpc
-        // so this 'raw' rpc call is required to extract the hash of the block with a certain height
-        let rpc_client = RpcClient::from_url(client_url).await?;
-        let hash: subxt::utils::H256 = rpc_client
-            .request("chain_getBlockHash", rpc_params![height])
-            .await?;
-
-        let block = client.blocks().at(hash).await?;
-
-        let header = block.header().clone();
-
-        let mut nmt_root = None;
-        for log in &header.digest.logs {
-            match log {
-                subxt::config::substrate::DigestItem::Other(ref bytes) => {
-                    if bytes.starts_with(b"snmt") {
-                        nmt_root = Some(sugondat_nmt::TreeRoot::from_raw_bytes(
-                            bytes[4..].try_into().unwrap(),
-                        ));
-                        break;
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        // fetch timestamp from block
-        let timestamp = block
-            .storage()
-            .fetch(&storage().timestamp().now())
-            .await?
-            .ok_or(anyhow::anyhow!("no timestamp found"))?;
-
+        let client = self.client.ensure_connected().await?;
+        let block: sugondat_shim_common_sovereign::Block =
+            client.get_block(height, self.namespace).await?;
         let header = types::Header::new(
-            types::Hash(hash.0),
-            types::Hash(header.parent_hash.0),
-            nmt_root.unwrap(),
-            header.number as u64,
-            timestamp,
+            Hash(block.block_hash),
+            Hash(block.prev_hash),
+            block.nmt_root,
+            height,
+            block.timestamp,
         );
-
-        let mut transactions = vec![];
-        for ext in block.extrinsics().await?.iter() {
-            let ext = ext?;
-            let Some(address) = ext.address_bytes().map(|a| {
-				tracing::info!("Address: {:?}", hex::encode(&a));
-				types::Address::try_from(&a[1..]).unwrap()
-			}) else {
-				continue
-			};
-            let Ok(Some(submit_blob_extrinsic)) =
-				ext.as_extrinsic::<sugondat_subxt::sugondat::blobs::calls::types::SubmitBlob>()
-			else {
-				// Not a submit blob extrinsic, skip.
-				continue
-			};
-
-            if submit_blob_extrinsic.namespace_id != namespace.namespace_id() {
-                // Not for our app.
-                continue;
-            }
-
-            let blob_data = submit_blob_extrinsic.blob.0;
-            tracing::info!("received a blob: {}", hex::encode(&blob_data));
-            transactions.push(types::BlobTransaction::new(address, blob_data));
-        }
-
-        let address = sugondat_subxt::sugondat::blobs::storage::StorageApi.blob_list();
-        let blobs = client
-            .storage()
-            .at(hash)
-            .fetch(&address)
-            .await
-            .unwrap()
-            .map(|x| x.0)
-            .unwrap_or_default();
-
-        let blobs = blobs
+        let transactions = block
+            .blobs
             .into_iter()
-            .map(|blob| sugondat_nmt::BlobMetadata {
-                namespace: sugondat_nmt::Namespace::with_namespace_id(blob.namespace_id),
-                leaf: sugondat_nmt::NmtLeaf {
-                    extrinsic_index: blob.extrinsic_index,
-                    who: blob.who.0,
-                    blob_hash: blob.blob_hash,
-                },
-            })
+            .map(|blob| types::BlobTransaction::new(types::Address(blob.sender), blob.data))
             .collect();
-        let mut tree = sugondat_nmt::tree_from_blobs(blobs);
-        let blob_proof = tree.proof(namespace);
-
         Ok(types::Block {
             header,
             transactions,
-            blob_proof,
+            blob_proof: block.proof,
         })
     }
 
@@ -200,25 +102,8 @@ impl sov_rollup_interface::services::da::DaService for DaProvider {
 
     // Send the blob to the DA layer, using the submit_blob extrinsic
     async fn send_transaction(&self, blob: &[u8]) -> Result<(), Self::Error> {
-        let client = self.client.clone();
-        let blob = blob.to_vec();
-        let namespace_id = self.namespace.namespace_id();
-        use subxt_signer::sr25519::dev;
-
-        let client = client.client().await?;
-
-        let extrinsic = sugondat_subxt::sugondat::tx()
-            .blobs()
-            .submit_blob(namespace_id, BoundedVec(blob));
-
-        let from = dev::alice();
-        let _events = client
-            .tx()
-            .sign_and_submit_then_watch_default(&extrinsic, &from)
-            .await?
-            .wait_for_finalized_success()
-            .await?;
-
+        let client = self.client.ensure_connected().await?;
+        client.submit_blob(blob.to_vec(), self.namespace).await?;
         Ok(())
     }
 }
diff --git a/sugondat-da-adapter/src/service/client.rs b/sugondat-da-adapter/src/service/client.rs
@@ -10,7 +10,20 @@ pub struct Client {
 
 struct Inner {
     url: String,
-    client: Option<sugondat_subxt::Client>,
+    client: Option<ClientRef>,
+}
+
+#[derive(Clone)]
+pub struct ClientRef {
+    client: Arc<jsonrpsee::ws_client::WsClient>,
+}
+
+impl std::ops::Deref for ClientRef {
+    type Target = jsonrpsee::ws_client::WsClient;
+
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
 }
 
 impl Client {
@@ -20,18 +33,18 @@ impl Client {
         }
     }
 
-    pub async fn url(&self) -> String {
-        let inner = self.inner.lock().await;
-        inner.url.clone()
-    }
-
-    pub async fn client(&self) -> anyhow::Result<sugondat_subxt::Client> {
+    pub async fn ensure_connected(&self) -> anyhow::Result<ClientRef> {
         let mut inner = self.inner.lock().await;
         if let Some(client) = &inner.client {
             return Ok(client.clone());
         }
 
-        let client = sugondat_subxt::Client::from_url(&inner.url).await?;
+        let client = jsonrpsee::ws_client::WsClientBuilder::new()
+            .build(inner.url.clone())
+            .await?;
+        let client = ClientRef {
+            client: Arc::new(client),
+        };
         inner.client = Some(client.clone());
         Ok(client)
     }
diff --git a/sugondat-shim/common/sovereign/src/lib.rs b/sugondat-shim/common/sovereign/src/lib.rs
@@ -1,8 +1,10 @@
-use jsonrpsee::{proc_macros::rpc, types::ErrorObjectOwned};
+use jsonrpsee::proc_macros::rpc;
 
 #[cfg(not(any(feature = "server", feature = "client")))]
 compile_error!("either feature \"server\" or \"client\" must be enabled");
 
+pub type JsonRPCError = jsonrpsee::types::ErrorObjectOwned;
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Block {
     // TODO: Hash should be a newtype that serializes to hex.
@@ -31,12 +33,12 @@ pub trait SovereignRPC {
         &self,
         height: u64,
         namespace: sugondat_nmt::Namespace,
-    ) -> Result<Block, ErrorObjectOwned>;
+    ) -> Result<Block, JsonRPCError>;
 
     #[method(name = "sovereign_submitBlob")]
     async fn submit_blob(
         &self,
         blob: Vec<u8>,
         namespace: sugondat_nmt::Namespace,
-    ) -> Result<(), ErrorObjectOwned>;
+    ) -> Result<(), JsonRPCError>;
 }
