Feat/675 on chain ouis devaddrs

Cargo.toml

@@ -22,4 +22,4 @@ helium-crypto = { version = "0.8" }
 helium-proto = { git = "https://github.com/helium/proto", branch = "master", features = [
     "services",
 ] }
-clap = { version = "4", features = ["derive"] }
+clap = { version = "4", features = ["derive"] }

helium-lib/Cargo.toml

@@ -41,11 +41,11 @@ serde = {workspace = true}
 serde_json = {workspace = true}
 lazy_static = "1"
 rust_decimal = {workspace = true}
-helium-proto = {workspace= true}
+helium-proto = {workspace = true}
 angry-purple-tiger = "0"
 sha2 = {workspace = true}
 clap = {workspace = true, optional = true}
 helium-mnemonic = { path = "../helium-mnemonic", optional = true }
 
 [dev-dependencies]
-rand = "0.8"
+rand = "0.8"

helium-lib/src/asset.rs

@@ -16,6 +16,14 @@ use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, result::Result as StdResult, str::FromStr};
 
+pub fn shared_merkle_key(proof_size: u8) -> Pubkey {
+    Pubkey::find_program_address(
+        &[b"shared_merkle", &[proof_size]],
+        &helium_entity_manager::ID,
+    )
+    .0
+}
+
 pub async fn for_entity_key<E, C: AsRef<DasClient>>(
     client: &C,
     entity_key: &E,
@@ -53,6 +61,7 @@ pub async fn get_with_proof<C: AsRef<DasClient>>(
     let (asset, asset_proof) = futures::try_join!(get(client, pubkey), proof::get(client, pubkey))?;
     Ok((asset, asset_proof))
 }
+
 pub mod canopy {
     use super::*;
     use spl_account_compression::state::{merkle_tree_get_size, ConcurrentMerkleTreeHeader};

helium-lib/src/client.rs

@@ -3,15 +3,19 @@ use crate::{
     asset,
     error::{DecodeError, Error},
     is_zero,
-    keypair::{self, Pubkey},
+    keypair::{self, Keypair, Pubkey},
     solana_client,
+    solana_sdk::{commitment_config::CommitmentConfig, signer::Signer},
 };
+
 use futures::{stream, StreamExt, TryStreamExt};
 use itertools::Itertools;
 use jsonrpc_client::{JsonRpcError, SendRequest};
 use std::{marker::Send, sync::Arc};
 use tracing::instrument;
 
+pub use solana_client::nonblocking::rpc_client::RpcClient as SolanaRpcClient;
+
 pub static ONBOARDING_URL_MAINNET: &str = "https://onboarding.dewi.org/api/v3";
 pub static ONBOARDING_URL_DEVNET: &str = "https://onboarding.web.test-helium.com/api/v3";
 
@@ -23,17 +27,104 @@ pub static SOLANA_URL_DEVNET: &str = "https://solana-rpc.web.test-helium.com?ses
 pub static SOLANA_URL_MAINNET_ENV: &str = "SOLANA_MAINNET_URL";
 pub static SOLANA_URL_DEVNET_ENV: &str = "SOLANA_DEVNET_URL";
 
-pub use solana_client::nonblocking::rpc_client::RpcClient as SolanaRpcClient;
+static USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
+
+#[derive(Clone)]
+pub struct SolanaClient {
+    pub inner: Arc<SolanaRpcClient>,
+    pub base_url: String,
+    pub wallet: Option<Arc<Keypair>>,
+}
+
+impl Default for SolanaClient {
+    fn default() -> Self {
+        // safe to unwrap
+        Self::new(SOLANA_URL_MAINNET, None).unwrap()
+    }
+}
+
+impl SolanaClient {
+    pub fn new(url: &str, wallet: Option<Arc<Keypair>>) -> Result<Self, Error> {
+        let client = Arc::new(
+            solana_client::nonblocking::rpc_client::RpcClient::new_with_commitment(
+                url.to_string(),
+                CommitmentConfig::finalized(),
+            ),
+        );
+
+        Ok(Self {
+            inner: client,
+            base_url: url.to_string(),
+            wallet,
+        })
+    }
+
+    pub fn ws_url(&self) -> String {
+        self.base_url
+            .replace("https", "wss")
+            .replace("http", "ws")
+            .replace("127.0.0.1:8899", "127.0.0.1:8900")
+    }
+
+    pub fn pubkey(&self) -> Result<Pubkey, Error> {
+        self.wallet
+            .as_ref()
+            .map(|wallet| wallet.pubkey())
+            .ok_or_else(|| Error::WalletUnconfigured)
+    }
+}
 
 #[derive(Clone)]
 pub struct Client {
-    pub solana_client: Arc<SolanaRpcClient>,
+    pub solana_client: Arc<SolanaClient>,
     pub das_client: Arc<DasClient>,
 }
 
+impl TryFrom<&str> for Client {
+    type Error = Error;
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        fn env_or(key: &str, default: &str) -> String {
+            std::env::var(key).unwrap_or_else(|_| default.to_string())
+        }
+        let url = match value {
+            "m" | "mainnet-beta" => &env_or(SOLANA_URL_MAINNET_ENV, SOLANA_URL_MAINNET),
+            "d" | "devnet" => &env_or(SOLANA_URL_DEVNET_ENV, SOLANA_URL_DEVNET),
+            url => url,
+        };
+        let das_client = Arc::new(DasClient::with_base_url(url)?);
+        let solana_client = Arc::new(SolanaClient::new(url, None)?);
+
+        Ok(Self {
+            solana_client,
+            das_client,
+        })
+    }
+}
+
+impl AsRef<SolanaRpcClient> for SolanaClient {
+    fn as_ref(&self) -> &SolanaRpcClient {
+        &self.inner
+    }
+}
+
+impl AsRef<SolanaRpcClient> for Client {
+    fn as_ref(&self) -> &SolanaRpcClient {
+        &self.solana_client.inner
+    }
+}
+
+impl AsRef<DasClient> for Client {
+    fn as_ref(&self) -> &DasClient {
+        &self.das_client
+    }
+}
+
 #[async_trait::async_trait]
 pub trait GetAnchorAccount {
-    async fn anchor_account<T: AccountDeserialize>(&self, pubkey: &Pubkey) -> Result<T, Error>;
+    async fn anchor_account<T: AccountDeserialize>(
+        &self,
+        pubkey: &Pubkey,
+    ) -> Result<Option<T>, Error>;
     async fn anchor_accounts<T: AccountDeserialize + Send>(
         &self,
         pubkeys: &[Pubkey],
@@ -42,18 +133,21 @@ pub trait GetAnchorAccount {
 
 #[async_trait::async_trait]
 impl GetAnchorAccount for SolanaRpcClient {
-    async fn anchor_account<T: AccountDeserialize>(&self, pubkey: &Pubkey) -> Result<T, Error> {
+    async fn anchor_account<T: AccountDeserialize>(
+        &self,
+        pubkey: &Pubkey,
+    ) -> Result<Option<T>, Error> {
         let account = self.get_account(pubkey).await?;
         let decoded = T::try_deserialize(&mut account.data.as_ref())?;
-        Ok(decoded)
+        Ok(Some(decoded))
     }
 
     async fn anchor_accounts<T: AccountDeserialize + Send>(
         &self,
         pubkeys: &[Pubkey],
     ) -> Result<Vec<Option<T>>, Error> {
         async fn get_accounts<A: AccountDeserialize + Send>(
-            client: &SolanaRpcClient,
+            client: &solana_client::nonblocking::rpc_client::RpcClient,
             pubkeys: &[Pubkey],
         ) -> Result<Vec<Option<A>>, Error> {
             let accounts = client.get_multiple_accounts(pubkeys).await?;
@@ -86,46 +180,14 @@ impl GetAnchorAccount for Client {
     async fn anchor_account<T: AccountDeserialize>(
         &self,
         pubkey: &keypair::Pubkey,
-    ) -> Result<T, Error> {
-        self.solana_client.anchor_account(pubkey).await
+    ) -> Result<Option<T>, Error> {
+        self.solana_client.inner.anchor_account(pubkey).await
     }
     async fn anchor_accounts<T: AccountDeserialize + Send>(
         &self,
         pubkeys: &[Pubkey],
     ) -> Result<Vec<Option<T>>, Error> {
-        self.solana_client.anchor_accounts(pubkeys).await
-    }
-}
-
-impl TryFrom<&str> for Client {
-    type Error = Error;
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
-        fn env_or(key: &str, default: &str) -> String {
-            std::env::var(key).unwrap_or_else(|_| default.to_string())
-        }
-        let url = match value {
-            "m" | "mainnet-beta" => &env_or(SOLANA_URL_MAINNET_ENV, SOLANA_URL_MAINNET),
-            "d" | "devnet" => &env_or(SOLANA_URL_DEVNET_ENV, SOLANA_URL_DEVNET),
-            url => url,
-        };
-        let das_client = Arc::new(DasClient::with_base_url(url)?);
-        let solana_client = Arc::new(SolanaRpcClient::new(url.to_string()));
-        Ok(Self {
-            solana_client,
-            das_client,
-        })
-    }
-}
-
-impl AsRef<SolanaRpcClient> for Client {
-    fn as_ref(&self) -> &SolanaRpcClient {
-        &self.solana_client
-    }
-}
-
-impl AsRef<DasClient> for Client {
-    fn as_ref(&self) -> &DasClient {
-        &self.das_client
+        self.solana_client.inner.anchor_accounts(pubkeys).await
     }
 }
 
@@ -199,8 +261,6 @@ impl DasClientError {
 #[jsonrpc_client::api]
 pub trait DAS {}
 
-static USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
-
 #[jsonrpc_client::implement(DAS)]
 #[derive(Debug, Clone)]
 pub struct DasClient {