bug: fetch return types not qualified properly

Author: wjthieme

.changeset/eighty-owls-drum.md

@@ -0,0 +1,5 @@
+---
+'@codama/renderers-rust': patch
+---
+
+Fix a bug where types from sharedPage where not qualified correctly in the account fetch functions

packages/renderers-rust/e2e/system/src/generated/accounts/nonce.rs

@@ -54,25 +54,25 @@ impl<'a> TryFrom<&solana_program::account_info::AccountInfo<'a>> for Nonce {
 pub fn fetch_nonce(
     rpc: &solana_client::rpc_client::RpcClient,
     address: &Pubkey,
-) -> Result<super::DecodedAccount<Nonce>, Error> {
-    let accounts = fetch_all_nonce(rpc, vec![address])?;
+) -> Result<crate::DecodedAccount<Nonce>, std::io::Error> {
+    let accounts = fetch_all_nonce(rpc, vec![*address])?;
     Ok(accounts[0].clone())
 }
 
 #[cfg(feature = "fetch")]
 pub fn fetch_all_nonce(
     rpc: &solana_client::rpc_client::RpcClient,
     addresses: Vec<Pubkey>,
-) -> Result<Vec<super::DecodedAccount<Nonce>>, Error> {
+) -> Result<Vec<crate::DecodedAccount<Nonce>>, std::io::Error> {
     let accounts = rpc.get_multiple_accounts(&addresses)?;
-    let mut decoded_accounts: Vec<super::DecodedAccount<Nonce>> = Vec::new();
+    let mut decoded_accounts: Vec<crate::DecodedAccount<Nonce>> = Vec::new();
     for i in 0..addresses.len() {
         let address = addresses[i];
         let account = accounts[i]
             .as_ref()
             .ok_or(format!("Account not found: {}", address))?;
         let data = Nonce::from_bytes(&account.data)?;
-        decoded_accounts.push(super::DecodedAccount {
+        decoded_accounts.push(crate::DecodedAccount {
             address,
             account: account.clone(),
             data,
@@ -85,29 +85,29 @@ pub fn fetch_all_nonce(
 pub fn fetch_maybe_nonce(
     rpc: &solana_client::rpc_client::RpcClient,
     address: &Pubkey,
-) -> Result<super::MaybeAccount<Nonce>, Error> {
-    let accounts = fetch_all_maybe_nonce(rpc, vec![address])?;
+) -> Result<crate::MaybeAccount<Nonce>, std::io::Error> {
+    let accounts = fetch_all_maybe_nonce(rpc, vec![*address])?;
     Ok(accounts[0].clone())
 }
 
 #[cfg(feature = "fetch")]
 pub fn fetch_all_maybe_nonce(
     rpc: &solana_client::rpc_client::RpcClient,
     addresses: Vec<Pubkey>,
-) -> Result<Vec<super::MaybeAccount<Nonce>>, Error> {
+) -> Result<Vec<crate::MaybeAccount<Nonce>>, std::io::Error> {
     let accounts = rpc.get_multiple_accounts(&addresses)?;
-    let mut decoded_accounts: Vec<super::MaybeAccount<Nonce>> = Vec::new();
+    let mut decoded_accounts: Vec<crate::MaybeAccount<Nonce>> = Vec::new();
     for i in 0..addresses.len() {
         let address = addresses[i];
         if let Some(account) = accounts[i].as_ref() {
             let data = Nonce::from_bytes(&account.data)?;
-            decoded_accounts.push(super::MaybeAccount::Exists(super::DecodedAccount {
+            decoded_accounts.push(crate::MaybeAccount::Exists(crate::DecodedAccount {
                 address,
                 account: account.clone(),
                 data,
             }));
         } else {
-            decoded_accounts.push(super::MaybeAccount::NotFound(address));
+            decoded_accounts.push(crate::MaybeAccount::NotFound(address));
         }
     }
     Ok(decoded_accounts)

packages/renderers-rust/public/templates/accountsPage.njk

@@ -132,23 +132,23 @@ impl<'a> TryFrom<&solana_program::account_info::AccountInfo<'a>> for {{ account.
 pub fn fetch_{{ account.name | snakeCase }}(
   rpc: &solana_client::rpc_client::RpcClient,
   address: &Pubkey,
-) -> Result<super::DecodedAccount<{{ account.name | pascalCase }}>, Error> {
-  let accounts = fetch_all_{{ account.name | snakeCase }}(rpc, vec![address])?;
+) -> Result<crate::DecodedAccount<{{ account.name | pascalCase }}>, std::io::Error> {
+  let accounts = fetch_all_{{ account.name | snakeCase }}(rpc, vec![*address])?;
   Ok(accounts[0].clone())
 }
 
 #[cfg(feature = "fetch")]
 pub fn fetch_all_{{ account.name | snakeCase }}(
   rpc: &solana_client::rpc_client::RpcClient,
   addresses: Vec<Pubkey>,
-) -> Result<Vec<super::DecodedAccount<{{ account.name | pascalCase }}>>, Error> {
+) -> Result<Vec<crate::DecodedAccount<{{ account.name | pascalCase }}>>, std::io::Error> {
     let accounts = rpc.get_multiple_accounts(&addresses)?;
-    let mut decoded_accounts: Vec<super::DecodedAccount<{{ account.name | pascalCase }}>> = Vec::new();
+    let mut decoded_accounts: Vec<crate::DecodedAccount<{{ account.name | pascalCase }}>> = Vec::new();
     for i in 0..addresses.len() {
       let address = addresses[i];
       let account = accounts[i].as_ref().ok_or(format!("Account not found: {}", address))?;
       let data = {{ account.name | pascalCase }}::from_bytes(&account.data)?;
-      decoded_accounts.push(super::DecodedAccount { address, account: account.clone(), data });
+      decoded_accounts.push(crate::DecodedAccount { address, account: account.clone(), data });
     }
     Ok(decoded_accounts)
 }
@@ -157,25 +157,25 @@ pub fn fetch_all_{{ account.name | snakeCase }}(
 pub fn fetch_maybe_{{ account.name | snakeCase }}(
   rpc: &solana_client::rpc_client::RpcClient,
   address: &Pubkey,
-) -> Result<super::MaybeAccount<{{ account.name | pascalCase }}>, Error> {
-    let accounts = fetch_all_maybe_{{ account.name | snakeCase }}(rpc, vec![address])?;
+) -> Result<crate::MaybeAccount<{{ account.name | pascalCase }}>, std::io::Error> {
+    let accounts = fetch_all_maybe_{{ account.name | snakeCase }}(rpc, vec![*address])?;
     Ok(accounts[0].clone())
 }
 
 #[cfg(feature = "fetch")]
 pub fn fetch_all_maybe_{{ account.name | snakeCase }}(
   rpc: &solana_client::rpc_client::RpcClient,
   addresses: Vec<Pubkey>,
-) -> Result<Vec<super::MaybeAccount<{{ account.name | pascalCase }}>>, Error> {
+) -> Result<Vec<crate::MaybeAccount<{{ account.name | pascalCase }}>>, std::io::Error> {
     let accounts = rpc.get_multiple_accounts(&addresses)?;
-    let mut decoded_accounts: Vec<super::MaybeAccount<{{ account.name | pascalCase }}>> = Vec::new();
+    let mut decoded_accounts: Vec<crate::MaybeAccount<{{ account.name | pascalCase }}>> = Vec::new();
     for i in 0..addresses.len() {
       let address = addresses[i];
       if let Some(account) = accounts[i].as_ref() {
         let data = {{ account.name | pascalCase }}::from_bytes(&account.data)?;
-        decoded_accounts.push(super::MaybeAccount::Exists(super::DecodedAccount { address, account: account.clone(), data }));
+        decoded_accounts.push(crate::MaybeAccount::Exists(crate::DecodedAccount { address, account: account.clone(), data }));
       } else {
-        decoded_accounts.push(super::MaybeAccount::NotFound(address));
+        decoded_accounts.push(crate::MaybeAccount::NotFound(address));
       }
     }
   Ok(decoded_accounts)