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

@@ -28,7 +28,7 @@ bincode = "1.3.3"
 reqwest = { version = "0", default-features = false, features = [
     "rustls-tls",
 ] }
-helium-anchor-gen = {git = "https://github.com/helium/helium-anchor-gen.git" }
+helium-anchor-gen = { git = "https://github.com/helium/helium-anchor-gen.git" }
 spl-associated-token-account = { version = "*", features = ["no-entrypoint"] }
 spl-account-compression = { version = "0.3", features = ["no-entrypoint"] }
 spl-memo = "4"
@@ -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

@@ -8,14 +8,57 @@ use crate::{
     keypair::{serde_opt_pubkey, serde_pubkey, Keypair, Pubkey},
     kta, mk_transaction_with_blockhash,
     priority_fee::{compute_budget_instruction, compute_price_instruction_for_accounts},
-    programs::{SPL_ACCOUNT_COMPRESSION_PROGRAM_ID, SPL_NOOP_PROGRAM_ID},
+    programs::{
+        SPL_ACCOUNT_COMPRESSION_PROGRAM_ID, SPL_NOOP_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID,
+    },
     solana_sdk::{instruction::AccountMeta, transaction::Transaction},
     TransactionOpts,
 };
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, result::Result as StdResult, str::FromStr};
 
+pub fn bubblegum_signer_key() -> Pubkey {
+    Pubkey::find_program_address(&[b"collection_cpi"], &mpl_bubblegum::ID).0
+}
+
+pub fn collection_metadata_key(collection_key: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(
+        &[
+            b"metadata",
+            TOKEN_METADATA_PROGRAM_ID.as_ref(),
+            collection_key.as_ref(),
+        ],
+        &TOKEN_METADATA_PROGRAM_ID,
+    )
+    .0
+}
+
+pub fn collection_master_edition_key(collection_key: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(
+        &[
+            b"metadata",
+            TOKEN_METADATA_PROGRAM_ID.as_ref(),
+            collection_key.as_ref(),
+            b"edition",
+        ],
+        &TOKEN_METADATA_PROGRAM_ID,
+    )
+    .0
+}
+
+pub fn merkle_tree_authority_key(merkle_tree: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(&[merkle_tree.as_ref()], &mpl_bubblegum::ID).0
+}
+
+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 +96,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,22 @@ use crate::{
     asset,
     error::{DecodeError, Error},
     is_zero,
-    keypair::{self, Pubkey},
+    keypair::{self, Keypair, Pubkey},
+    priority_fee::auto_compute_limit_and_price,
     solana_client,
+    solana_sdk::{commitment_config::CommitmentConfig, signer::Signer},
 };
+
+use anchor_client::solana_client::send_and_confirm_transactions_in_parallel;
 use futures::{stream, StreamExt, TryStreamExt};
 use itertools::Itertools;
 use jsonrpc_client::{JsonRpcError, SendRequest};
+use solana_sdk::{instruction::Instruction, message::Message, transaction::Transaction};
 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 +30,153 @@ 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 keypair: 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, keypair: Option<Arc<Keypair>>) -> Result<Self, Error> {
+        let client = Arc::new(
+            solana_client::nonblocking::rpc_client::RpcClient::new_with_commitment(
+                url.to_string(),
+                CommitmentConfig::finalized(),
+            ),
+        );
+
+        // Add debug print for keypair
+        if let Some(kp) = &keypair {
+            println!("Initializing SolanaClient with keypair: {:?}", kp.pubkey());
+        } else {
+            println!("Initializing SolanaClient without keypair");
+        }
+
+        Ok(Self {
+            inner: client,
+            base_url: url.to_string(),
+            keypair,
+        })
+    }
+
+    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.keypair
+            .as_ref()
+            .map(|keypair| keypair.pubkey())
+            .ok_or_else(|| Error::KeypairUnconfigured)
+    }
+
+    pub async fn send_instructions(
+        &self,
+        ixs: &[Instruction],
+        extra_signers: &[Keypair],
+    ) -> Result<(), Error> {
+        let keypair = self
+            .keypair
+            .as_ref()
+            .ok_or_else(|| Error::KeypairUnconfigured)?;
+
+        if ixs.is_empty() {
+            return Ok(());
+        }
+
+        let signers: Vec<&dyn Signer> = std::iter::once(keypair.as_ref() as &dyn Signer)
+            .chain(extra_signers.iter().map(|k| k as &dyn Signer))
+            .collect();
+
+        let (recent_blockhash, _) = self
+            .inner
+            .get_latest_blockhash_with_commitment(CommitmentConfig::finalized())
+            .await?;
+
+        let optimized_ixs = auto_compute_limit_and_price(
+            &self.inner,
+            ixs,
+            &signers,
+            1.2,
+            Some(&keypair.pubkey()),
+            Some(recent_blockhash),
+        )
+        .await?;
+
+        let message = Message::new(&optimized_ixs, Some(&keypair.pubkey()));
+        let transaction = Transaction::new(&signers, message, recent_blockhash);
+        self.inner
+            .send_and_confirm_transaction_with_spinner(&transaction)
+            .await?;
+
+        Ok(())
+    }
+}
 
 #[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 +185,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 +232,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 +313,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 {