refactor(pinocchio): migrate account_view naming and ToAccountView APIs across lang/client/cli/spl

Author: user.email

client/src/lib.rs

@@ -64,15 +64,14 @@
 //!
 //! [`RpcClient::new_mock`]: https://docs.rs/solana-rpc-client/3.0.0/solana_rpc_client/rpc_client/struct.RpcClient.html#method.new_mock
 
-use anchor_lang::pinocchio_runtime::instruction::{AccountMeta, InstructionView};
 use anchor_lang::pinocchio_runtime::program_error::ProgramError;
 use anchor_lang::pinocchio_runtime::pubkey::Pubkey;
-use anchor_lang::prelude::instruction::InstructionView;
 use anchor_lang::{AccountDeserialize, Discriminator, InstructionData, ToAccountMetas};
 use futures::{Future, StreamExt};
 use regex::Regex;
 use solana_account_decoder::{UiAccount, UiAccountEncoding};
 use solana_commitment_config::CommitmentConfig;
+use solana_instruction::{AccountMeta as SolanaAccountMeta, Instruction};
 use solana_program::hash::Hash;
 use solana_pubsub_client::nonblocking::pubsub_client::{PubsubClient, PubsubClientError};
 use solana_rpc_client::nonblocking::rpc_client::RpcClient as AsyncRpcClient;
@@ -499,12 +498,12 @@ impl AsSigner for Box<dyn Signer + '_> {
 
 /// `RequestBuilder` provides a builder interface to create and send
 /// transactions to a cluster.
-pub struct RequestBuilder<'a, 'b, 'c, 'd, C, S: 'a> {
+pub struct RequestBuilder<'a, C, S: 'a> {
     cluster: String,
     program_id: Pubkey,
-    accounts: Vec<AccountMeta<'a>>,
+    accounts: Vec<SolanaAccountMeta>,
     options: CommitmentConfig,
-    instructions: Vec<InstructionView<'a, 'b, 'c, 'd>>,
+    instructions: Vec<Instruction>,
     payer: C,
     instruction_data: Option<Vec<u8>>,
     signers: Vec<S>,
@@ -515,7 +514,7 @@ pub struct RequestBuilder<'a, 'b, 'c, 'd, C, S: 'a> {
 }
 
 // Shared implementation for all RequestBuilders
-impl<C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'_, '_, '_, '_, C, S> {
+impl<'a, C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'a, C, S> {
     #[must_use]
     pub fn payer(mut self, payer: C) -> Self {
         self.payer = payer;
@@ -529,7 +528,7 @@ impl<C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'_, '_,
     }
 
     #[must_use]
-    pub fn instruction(mut self, ix: InstructionView<'_, '_, '_, '_>) -> Self {
+    pub fn instruction(mut self, ix: Instruction) -> Self {
         self.instructions.push(ix);
         self
     }
@@ -571,9 +570,18 @@ impl<C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'_, '_,
     ///     .send()?;
     /// ```
     #[must_use]
-    pub fn accounts(mut self, accounts: impl ToAccountMetas) -> Self {
-        let mut metas = accounts.to_account_metas(None);
-        self.accounts.append(&mut metas);
+    pub fn accounts(mut self, accounts: impl ToAccountMetas + 'a) -> Self {
+        self.accounts
+            .extend(
+                accounts
+                    .to_account_metas(None)
+                    .into_iter()
+                    .map(|meta| SolanaAccountMeta {
+                        pubkey: *meta.address,
+                        is_signer: meta.is_signer,
+                        is_writable: meta.is_writable,
+                    }),
+            );
         self
     }
 
@@ -589,10 +597,10 @@ impl<C: Deref<Target = impl Signer> + Clone, S: AsSigner> RequestBuilder<'_, '_,
         self
     }
 
-    pub fn instructions(&self) -> Vec<InstructionView> {
+    pub fn instructions(&self) -> Vec<Instruction> {
         let mut instructions = self.instructions.clone();
         if let Some(ix_data) = &self.instruction_data {
-            instructions.push(InstructionView {
+            instructions.push(Instruction {
                 program_id: self.program_id,
                 data: ix_data.clone(),
                 accounts: self.accounts.clone(),

lang/attribute/access-control/src/lib.rs

@@ -31,7 +31,7 @@ use syn::parse_macro_input;
 ///
 /// impl Create {
 ///   pub fn accounts(ctx: &Context<Create>, bump_seed: u8) -> Result<()> {
-///     let seeds = &[ctx.accounts.my_account.to_account_info().key.as_ref(), &[bump_seed]];
+///     let seeds = &[ctx.accounts.my_account.to_account_view().key.as_ref(), &[bump_seed]];
 ///     Pubkey::create_program_address(seeds, ctx.program_id)
 ///       .map_err(|_| ErrorCode::InvalidNonce)?;
 ///     Ok(())

lang/attribute/event/src/lib.rs

@@ -163,7 +163,7 @@ pub fn emit_cpi(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 
     proc_macro::TokenStream::from(quote! {
         {
-            let authority_info = ctx.accounts.#authority_name.to_account_info();
+            let authority_info = ctx.accounts.#authority_name.to_account_view();
 
             let disc = anchor_lang::event::EVENT_IX_TAG_LE;
             let inner_data = anchor_lang::Event::data(&#event_struct);

lang/attribute/program/src/declare_program/mods/cpi.rs

@@ -83,7 +83,7 @@ fn gen_cpi_instructions(idl: &Idl) -> proc_macro2::TokenStream {
                     }
                 };
 
-                let mut acc_infos = ctx.to_account_infos();
+                let mut acc_infos = ctx.to_account_views();
                 anchor_lang::pinocchio_runtime::program::invoke_signed(
                     &ix,
                     &acc_infos,

lang/src/accounts/account.rs

@@ -2,21 +2,21 @@
 
 use crate::bpf_writer::BpfWriter;
 use crate::error::{Error, ErrorCode};
-use crate::pinocchio_runtime::account_info::AccountView;
+use crate::pinocchio_runtime::account_view::AccountView;
 use crate::pinocchio_runtime::bpf_loader_upgradeable::{self, UpgradeableLoaderState};
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
 use crate::pinocchio_runtime::system_program;
 use crate::{
     AccountDeserialize, AccountSerialize, Accounts, AccountsClose, AccountsExit, Id, Key, Owner,
-    Result, ToAccountInfo, ToAccountInfos, ToAccountMetas,
+    Result, ToAccountMetas, ToAccountView, ToAccountViews,
 };
 use std::collections::BTreeSet;
 use std::fmt;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 
-/// Wrapper around [`AccountView`](crate::pinocchio_runtime::account_info::AccountView)
+/// Wrapper around [`AccountView`](crate::pinocchio_runtime::account_view::AccountView)
 /// that verifies program ownership and deserializes underlying data into a Rust type.
 ///
 /// # Table of Contents
@@ -374,7 +374,7 @@ impl<'info, T: AccountChecks> AccountsExit<'info> for Account<'info, T> {
 
 impl<'info, T: AccountChecks> AccountsClose<'info> for Account<'info, T> {
     fn close(&self, sol_destination: AccountView) -> Result<()> {
-        crate::common::close(self.to_account_info(), sol_destination)
+        crate::common::close(self.to_account_view(), sol_destination)
     }
 }
 
@@ -391,8 +391,8 @@ impl<T: AccountChecks> ToAccountMetas for Account<'_, T> {
     }
 }
 
-impl<'info, T: AccountChecks> ToAccountInfos for Account<'info, T> {
-    fn to_account_infos(&self) -> Vec<AccountView> {
+impl<'info, T: AccountChecks> ToAccountViews for Account<'info, T> {
+    fn to_account_views(&self) -> Vec<AccountView> {
         vec![self.info]
     }
 }

lang/src/accounts/account_info.rs

@@ -3,10 +3,10 @@
 //! should be used instead.
 
 use crate::error::ErrorCode;
-use crate::pinocchio_runtime::account_info::AccountView;
+use crate::pinocchio_runtime::account_view::AccountView;
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
-use crate::{Accounts, AccountsExit, Key, Result, ToAccountInfos, ToAccountMetas};
+use crate::{Accounts, AccountsExit, Key, Result, ToAccountMetas, ToAccountViews};
 use std::collections::BTreeSet;
 
 impl<'info, B> Accounts<'info, B> for AccountView {
@@ -39,8 +39,8 @@ impl ToAccountMetas for AccountView {
     }
 }
 
-impl ToAccountInfos for AccountView {
-    fn to_account_infos(&self) -> Vec<AccountView> {
+impl ToAccountViews for AccountView {
+    fn to_account_views(&self) -> Vec<AccountView> {
         vec![*self]
     }
 }

lang/src/accounts/account_loader.rs

@@ -1,14 +1,14 @@
 //! Type facilitating on demand zero copy deserialization.
 
-use crate::pinocchio_runtime::account_info::{AccountView, Ref, RefMut};
+use crate::pinocchio_runtime::account_view::{AccountView, Ref, RefMut};
 
 use crate::bpf_writer::BpfWriter;
 use crate::error::{Error, ErrorCode};
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
 use crate::{
-    Accounts, AccountsClose, AccountsExit, Key, Owner, Result, ToAccountInfo, ToAccountInfos,
-    ToAccountMetas, ZeroCopy,
+    Accounts, AccountsClose, AccountsExit, Key, Owner, Result, ToAccountMetas, ToAccountView,
+    ToAccountViews, ZeroCopy,
 };
 
 use std::collections::BTreeSet;
@@ -252,7 +252,7 @@ impl<'info, T: ZeroCopy + Owner> AccountsExit<'info> for AccountLoader<'info, T>
 
 impl<'info, T: ZeroCopy + Owner> AccountsClose<'info> for AccountLoader<'info, T> {
     fn close(&self, sol_destination: AccountView) -> Result<()> {
-        crate::common::close(self.to_account_info(), sol_destination)
+        crate::common::close(self.to_account_view(), sol_destination)
     }
 }
 
@@ -275,8 +275,8 @@ impl<'info, T: ZeroCopy + Owner> AsRef<AccountView> for AccountLoader<'info, T>
     }
 }
 
-impl<'info, T: ZeroCopy + Owner> ToAccountInfos for AccountLoader<'info, T> {
-    fn to_account_infos(&self) -> Vec<AccountView> {
+impl<'info, T: ZeroCopy + Owner> ToAccountViews for AccountLoader<'info, T> {
+    fn to_account_views(&self) -> Vec<AccountView> {
         vec![self.acc_info]
     }
 }

lang/src/accounts/boxed.rs

@@ -13,10 +13,10 @@
 //! }
 //! ```
 
-use crate::pinocchio_runtime::account_info::AccountView;
+use crate::pinocchio_runtime::account_view::AccountView;
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
-use crate::{Accounts, AccountsClose, AccountsExit, Result, ToAccountInfos, ToAccountMetas};
+use crate::{Accounts, AccountsClose, AccountsExit, Result, ToAccountMetas, ToAccountViews};
 use std::collections::BTreeSet;
 use std::ops::Deref;
 
@@ -38,9 +38,9 @@ impl<'info, T: AccountsExit<'info>> AccountsExit<'info> for Box<T> {
     }
 }
 
-impl<T: ToAccountInfos> ToAccountInfos for Box<T> {
-    fn to_account_infos(&self) -> Vec<AccountView> {
-        T::to_account_infos(self)
+impl<T: ToAccountViews> ToAccountViews for Box<T> {
+    fn to_account_views(&self) -> Vec<AccountView> {
+        T::to_account_views(self)
     }
 }
 

lang/src/accounts/interface.rs

@@ -3,11 +3,11 @@
 use crate::accounts::account::AnyProgram;
 use crate::accounts::program::Program;
 use crate::error::{Error, ErrorCode};
-use crate::pinocchio_runtime::account_info::AccountView;
+use crate::pinocchio_runtime::account_view::AccountView;
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
 use crate::{
-    AccountDeserialize, Accounts, AccountsExit, CheckId, Key, Result, ToAccountInfos,
+    AccountDeserialize, Accounts, AccountsExit, CheckId, Key, Result, ToAccountViews,
     ToAccountMetas,
 };
 use std::collections::BTreeSet;
@@ -134,9 +134,9 @@ impl<T> ToAccountMetas for Interface<'_, T> {
     }
 }
 
-impl<'info, T> ToAccountInfos for Interface<'info, T> {
-    fn to_account_infos(&self) -> Vec<AccountView> {
-        self.program.to_account_infos()
+impl<'info, T> ToAccountViews for Interface<'info, T> {
+    fn to_account_views(&self) -> Vec<AccountView> {
+        self.program.to_account_views()
     }
 }
 

lang/src/accounts/interface_account.rs

@@ -2,20 +2,20 @@
 
 use crate::accounts::account::Account;
 use crate::error::{Error, ErrorCode};
-use crate::pinocchio_runtime::account_info::AccountView;
+use crate::pinocchio_runtime::account_view::AccountView;
 use crate::pinocchio_runtime::instruction::AccountMeta;
 use crate::pinocchio_runtime::pubkey::Pubkey;
 use crate::pinocchio_runtime::system_program;
 use crate::{
     AccountDeserialize, AccountSerialize, Accounts, AccountsClose, AccountsExit, CheckOwner, Key,
-    Owner, Owners, Result, ToAccountInfo, ToAccountInfos, ToAccountMetas,
+    Owner, Owners, Result, ToAccountMetas, ToAccountView, ToAccountViews,
 };
 use std::collections::BTreeSet;
 use std::convert::AsRef;
 use std::fmt;
 use std::ops::{Deref, DerefMut};
 
-/// Wrapper around [`AccountView`](crate::pinocchio_runtime::account_info::AccountView)
+/// Wrapper around [`AccountView`](crate::pinocchio_runtime::account_view::AccountView)
 /// that verifies program ownership and deserializes underlying data into a Rust type.
 ///
 /// # Table of Contents
@@ -194,7 +194,7 @@ impl<'a, T: AccountSerialize + AccountDeserialize + Owner + Clone> InterfaceAcco
     /// If you need discriminator validation on reload, use `Account<T>` with an Anchor
     /// #[account] type.
     pub fn reload(&mut self) -> Result<()> {
-        let info = self.account.to_account_info();
+        let info = self.account.to_account_view();
 
         // Enforce owner stability: must match the one validated at construction.
         if !info.owned_by(&self.owner) {
@@ -308,11 +308,11 @@ impl<T: AccountSerialize + AccountDeserialize + Owner + Clone> ToAccountMetas
     }
 }
 
-impl<'info, T: AccountSerialize + AccountDeserialize + Owner + Clone> ToAccountInfos
+impl<'info, T: AccountSerialize + AccountDeserialize + Owner + Clone> ToAccountViews
     for InterfaceAccount<'info, T>
 {
-    fn to_account_infos(&self) -> Vec<AccountView> {
-        self.account.to_account_infos()
+    fn to_account_views(&self) -> Vec<AccountView> {
+        self.account.to_account_views()
     }
 }