fix(v2): Port anchor-client to anchor-lang-v2

Author: jamie-osec

Cargo.lock

@@ -18,8 +18,10 @@ debug = []
 mock = []
 
 [dependencies]
-anchor-lang = { path = "../lang", version = "2.0.0" }
+anchor-lang-v2 = { path = "../lang-v2", version = "2.0.0" }
 anyhow = "1"
+base64 = "0.22"
+borsh = "1"
 futures = "0.3"
 regex = "1"
 serde = { version = "1", features = ["derive"] }

client/Cargo.toml

@@ -5,7 +5,8 @@ use {
         ClientError, Config, EventContext, EventUnsubscriber, Program, ProgramAccountsIterator,
         RequestBuilder,
     },
-    anchor_lang::{prelude::Pubkey, AccountDeserialize, Discriminator},
+    anchor_lang_v2::{AccountDeserialize, Discriminator},
+    solana_program::pubkey::Pubkey,
     solana_commitment_config::CommitmentConfig,
     solana_rpc_client::nonblocking::rpc_client::RpcClient as AsyncRpcClient,
     solana_rpc_client_api::{config::RpcSendTransactionConfig, filter::RpcFilterType},
@@ -98,7 +99,7 @@ impl<C: Deref<Target = impl Signer> + Clone> Program<C> {
         self.rt.block_on(self.accounts_lazy_internal(filters))
     }
 
-    pub fn on<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
+    pub fn on<T: anchor_lang_v2::Event + anchor_lang_v2::AnchorDeserialize>(
         &self,
         f: impl FnMut(&EventContext, T) + Send + 'static,
     ) -> Result<EventUnsubscriber<'_>, ClientError> {

client/src/blocking.rs

@@ -67,7 +67,7 @@
 #[cfg(feature = "async")]
 pub use nonblocking::ThreadSafeSigner;
 pub use {
-    anchor_lang,
+    anchor_lang_v2,
     cluster::Cluster,
     solana_commitment_config::CommitmentConfig,
     solana_instruction::Instruction,
@@ -81,10 +81,8 @@ pub use {
     solana_transaction::Transaction,
 };
 use {
-    anchor_lang::{
-        solana_program::{program_error::ProgramError, pubkey::Pubkey},
-        AccountDeserialize, Discriminator, InstructionData, ToAccountMetas,
-    },
+    anchor_lang_v2::{AccountDeserialize, Discriminator, InstructionData, ToAccountMetas},
+    solana_program::{program_error::ProgramError, pubkey::Pubkey},
     futures::{Future, StreamExt},
     regex::Regex,
     solana_account_decoder::{UiAccount, UiAccountEncoding},
@@ -295,7 +293,7 @@ impl<C: Deref<Target = impl Signer> + Clone> Program<C> {
         })
     }
 
-    async fn on_internal<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
+    async fn on_internal<T: anchor_lang_v2::Event + anchor_lang_v2::AnchorDeserialize>(
         &self,
         mut f: impl FnMut(&EventContext, T) + Send + 'static,
     ) -> Result<
@@ -370,14 +368,11 @@ impl<T> Iterator for ProgramAccountsIterator<T> {
     }
 }
 
-pub fn handle_program_log<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
+pub fn handle_program_log<T: anchor_lang_v2::Event + anchor_lang_v2::AnchorDeserialize>(
     self_program_str: &str,
     l: &str,
 ) -> Result<(Option<T>, Option<String>, bool), ClientError> {
-    use {
-        anchor_lang::__private::base64,
-        base64::{engine::general_purpose::STANDARD, Engine},
-    };
+    use base64::{engine::general_purpose::STANDARD, Engine};
 
     // Log emitted from the current program.
     if let Some(log) = l
@@ -477,8 +472,6 @@ pub enum ClientError {
     #[error("Account not found")]
     AccountNotFound,
     #[error("{0}")]
-    AnchorError(#[from] anchor_lang::error::Error),
-    #[error("{0}")]
     ProgramError(#[from] ProgramError),
     #[error("{0}")]
     SolanaClientError(#[from] Box<SolanaClientError>),
@@ -673,7 +666,7 @@ impl<C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'_, C,
     }
 }
 
-fn parse_logs_response<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
+fn parse_logs_response<T: anchor_lang_v2::Event + anchor_lang_v2::AnchorDeserialize>(
     logs: RpcResponse<RpcLogsResponse>,
     program_id_str: &str,
 ) -> Result<Vec<T>, ClientError> {
@@ -733,18 +726,29 @@ fn parse_logs_response<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
 
 #[cfg(test)]
 mod tests {
-    // Creating a mock struct that implements `anchor_lang::events`
-    // for type inference in `test_logs`
+    // Mock event: minimal manual impl avoiding the `#[event]` macro, which
+    // depends on the `wincode` derive (anchor-lang-v2 transitively pulls it
+    // in but the re-exported derive's generated code references the bare
+    // `wincode` path, not visible from this crate). The test only needs
+    // `Event + AnchorDeserialize + Discriminator` for type inference inside
+    // `parse_logs_response::<MockEvent>`.
     use {
-        anchor_lang::prelude::*,
+        anchor_lang_v2::{AnchorDeserialize, AnchorSerialize, Discriminator, Event},
         futures::{SinkExt, StreamExt},
         solana_rpc_client_api::response::RpcResponseContext,
         std::sync::atomic::{AtomicU64, Ordering},
         tokio_tungstenite::tungstenite::Message,
     };
-    #[derive(Debug, Clone, Copy)]
-    #[event]
+    #[derive(Debug, Clone, Copy, AnchorSerialize, AnchorDeserialize)]
     pub struct MockEvent {}
+    impl Discriminator for MockEvent {
+        const DISCRIMINATOR: &'static [u8] = &[0; 8];
+    }
+    impl Event for MockEvent {
+        fn data(&self) -> Vec<u8> {
+            Vec::new()
+        }
+    }
 
     use super::*;
     #[test]
@@ -775,7 +779,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_logs_response() -> Result<()> {
+    fn test_parse_logs_response() -> anyhow::Result<()> {
         // Mock logs received within an `RpcResponse`. These are based on a Jupiter transaction.
         let logs = vec![
             "Program VeryCoolProgram invoke [1]", // Outer instruction #1 starts
@@ -892,7 +896,7 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_logs_response_fake_pop() -> Result<()> {
+    fn test_parse_logs_response_fake_pop() -> anyhow::Result<()> {
         let logs = [
             "Program fake111111111111111111111111111111111111112 invoke [1]",
             "Program log: i logged success",

client/src/lib.rs

@@ -3,7 +3,8 @@ use {
         AsSigner, ClientError, Config, EventContext, EventUnsubscriber, Program,
         ProgramAccountsIterator, RequestBuilder,
     },
-    anchor_lang::{prelude::Pubkey, AccountDeserialize, Discriminator},
+    anchor_lang_v2::{AccountDeserialize, Discriminator},
+    solana_program::pubkey::Pubkey,
     solana_commitment_config::CommitmentConfig,
     solana_rpc_client::nonblocking::rpc_client::RpcClient as AsyncRpcClient,
     solana_rpc_client_api::{config::RpcSendTransactionConfig, filter::RpcFilterType},
@@ -107,7 +108,7 @@ impl<C: Deref<Target = impl Signer> + Clone> Program<C> {
     /// Subscribe to program logs.
     ///
     /// Returns an [`EventUnsubscriber`] to unsubscribe and close connection gracefully.
-    pub async fn on<T: anchor_lang::Event + anchor_lang::AnchorDeserialize>(
+    pub async fn on<T: anchor_lang_v2::Event + anchor_lang_v2::AnchorDeserialize>(
         &self,
         f: impl FnMut(&EventContext, T) + Send + 'static,
     ) -> Result<EventUnsubscriber<'_>, ClientError> {

client/src/nonblocking.rs

@@ -1089,6 +1089,67 @@ pub fn account(attr: TokenStream, item: TokenStream) -> TokenStream {
         Fields::Unit => Vec::new(),
     };
 
+    // Client-side `AccountDeserialize` impl. Mode-dependent: borsh accounts
+    // run `BorshDeserialize` over the post-disc tail; pod accounts do a
+    // `bytemuck::pod_read_unaligned` on a sized slice. Both share the disc-
+    // check shape so a wrong-type fetch surfaces as `InvalidAccountData`.
+    let account_deserialize_impl = if is_borsh {
+        quote! {
+            impl anchor_lang_v2::AccountDeserialize for #name {
+                fn try_deserialize(
+                    buf: &mut &[u8],
+                ) -> ::core::result::Result<Self, anchor_lang_v2::Error> {
+                    use anchor_lang_v2::Discriminator as _;
+                    if buf.len() < <Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR.len() {
+                        return Err(anchor_lang_v2::Error::AccountDataTooSmall);
+                    }
+                    let (disc, rest) = buf.split_at(<Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR.len());
+                    if disc != <Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR {
+                        return Err(anchor_lang_v2::Error::InvalidAccountData);
+                    }
+                    *buf = rest;
+                    Self::try_deserialize_unchecked(buf)
+                }
+                fn try_deserialize_unchecked(
+                    buf: &mut &[u8],
+                ) -> ::core::result::Result<Self, anchor_lang_v2::Error> {
+                    <Self as anchor_lang_v2::borsh::BorshDeserialize>::deserialize(buf)
+                        .map_err(|_| anchor_lang_v2::Error::InvalidAccountData)
+                }
+            }
+        }
+    } else {
+        quote! {
+            impl anchor_lang_v2::AccountDeserialize for #name {
+                fn try_deserialize(
+                    buf: &mut &[u8],
+                ) -> ::core::result::Result<Self, anchor_lang_v2::Error> {
+                    use anchor_lang_v2::Discriminator as _;
+                    if buf.len() < <Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR.len() {
+                        return Err(anchor_lang_v2::Error::AccountDataTooSmall);
+                    }
+                    let (disc, rest) = buf.split_at(<Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR.len());
+                    if disc != <Self as anchor_lang_v2::Discriminator>::DISCRIMINATOR {
+                        return Err(anchor_lang_v2::Error::InvalidAccountData);
+                    }
+                    *buf = rest;
+                    Self::try_deserialize_unchecked(buf)
+                }
+                fn try_deserialize_unchecked(
+                    buf: &mut &[u8],
+                ) -> ::core::result::Result<Self, anchor_lang_v2::Error> {
+                    let n = ::core::mem::size_of::<Self>();
+                    if buf.len() < n {
+                        return Err(anchor_lang_v2::Error::AccountDataTooSmall);
+                    }
+                    let value: Self = anchor_lang_v2::bytemuck::pod_read_unaligned(&buf[..n]);
+                    *buf = &buf[n..];
+                    Ok(value)
+                }
+            }
+        }
+    };
+
     let (struct_attrs, pod_impls) = if is_borsh {
         (
             quote! { #[derive(anchor_lang_v2::borsh::BorshSerialize, anchor_lang_v2::borsh::BorshDeserialize, Default)] },
@@ -1159,6 +1220,7 @@ pub fn account(attr: TokenStream, item: TokenStream) -> TokenStream {
         impl anchor_lang_v2::Discriminator for #name {
             const DISCRIMINATOR: &'static [u8] = &[#(#disc_literals),*];
         }
+        #account_deserialize_impl
         #[cfg(feature = "idl-build")]
         impl anchor_lang_v2::IdlAccountType for #name {
             const __IDL_TYPE: Option<&'static str> = Some(#idl_type_json);

lang-v2/derive/src/lib.rs

@@ -204,6 +204,30 @@ pub trait Discriminator {
     const DISCRIMINATOR: &'static [u8];
 }
 
+/// Client-side account deserialization. Mirrors v1 anchor-lang's trait so
+/// `anchor-client` can fetch raw account bytes and decode them into the
+/// user's `#[account]` struct. The `#[account]` macro emits two impl
+/// bodies:
+///
+///   - Borsh mode (`#[account(borsh)]`): check disc, run `BorshDeserialize`.
+///   - Pod mode (default): check disc, `bytemuck::pod_read_unaligned` on
+///     the post-disc bytes.
+///
+/// Not used by the on-chain account wrappers (`BorshAccount` / `Slab`),
+/// which read directly from `AccountView` borrows; this is purely the
+/// off-chain client helper.
+pub trait AccountDeserialize: Sized {
+    /// Verify the leading discriminator and decode. Default implementation
+    /// strips the disc and forwards to `try_deserialize_unchecked`.
+    fn try_deserialize(buf: &mut &[u8]) -> Result<Self, ProgramError> {
+        Self::try_deserialize_unchecked(buf)
+    }
+
+    /// Decode without verifying the discriminator. Used during initialization
+    /// when the bytes are zero or otherwise not yet stamped with the disc.
+    fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self, ProgramError>;
+}
+
 /// Wrapper-level init: creates the on-chain account and returns a loaded
 /// `Self`. `Slab<H, T>` and `BorshAccount<T>` get this automatically;
 /// custom wrappers implement it directly.