@codama/renderers-rust 1.0.21 → 1.1.0

package/dist/templates/instructionsCpiPage.njk

@@ -7,9 +7,9 @@
       {% endif %}
 
       {% if account.isSigner === 'either' %}
-        {% set type = '(&\'b solana_program::account_info::AccountInfo<\'a>, bool)' %}
+        {% set type = '(&\'b solana_account_info::AccountInfo<\'a>, bool)' %}
       {% else %}
-        {% set type = '&\'b solana_program::account_info::AccountInfo<\'a>' %}
+        {% set type = '&\'b solana_account_info::AccountInfo<\'a>' %}
       {% endif %}
 
       {% if account.isOptional %}
@@ -24,16 +24,16 @@
 /// `{{ instruction.name | snakeCase }}` CPI instruction.
 pub struct {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
   /// The program to invoke.
-  pub __program: &'b solana_program::account_info::AccountInfo<'a>,
+  pub __program: &'b solana_account_info::AccountInfo<'a>,
   {% for account in instruction.accounts %}
     {% if account.docs.length > 0 %}
       {{ macros.docblock(account.docs) }}
     {% endif %}
 
     {% if account.isSigner === 'either' %}
-      {% set type = '(&\'b solana_program::account_info::AccountInfo<\'a>, bool)' %}
+      {% set type = '(&\'b solana_account_info::AccountInfo<\'a>, bool)' %}
     {% else %}
-      {% set type = '&\'b solana_program::account_info::AccountInfo<\'a>' %}
+      {% set type = '&\'b solana_account_info::AccountInfo<\'a>' %}
     {% endif %}
 
     {% if account.isOptional %}
@@ -50,7 +50,7 @@ pub struct {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
 
 impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
   pub fn new(
-    program: &'b solana_program::account_info::AccountInfo<'a>,
+    program: &'b solana_account_info::AccountInfo<'a>,
     {% if instruction.accounts.length > 0 %}
       accounts: {{ instruction.name | pascalCase }}CpiAccounts<'a, 'b>,
     {% endif %}
@@ -69,15 +69,15 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
     }
   }
   #[inline(always)]
-  pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
+  pub fn invoke(&self) -> solana_program_entrypoint::ProgramResult {
     self.invoke_signed_with_remaining_accounts(&[], &[])
   }
   #[inline(always)]
-  pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]) -> solana_program::entrypoint::ProgramResult {
+  pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> solana_program_entrypoint::ProgramResult {
     self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
   }
   #[inline(always)]
-  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program::entrypoint::ProgramResult {
+  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_entrypoint::ProgramResult {
     self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
   }
   #[allow(clippy::arithmetic_side_effects)]
@@ -86,32 +86,32 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
   pub fn invoke_signed_with_remaining_accounts(
     &self,
     signers_seeds: &[&[&[u8]]],
-    remaining_accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]
-  ) -> solana_program::entrypoint::ProgramResult {
+    remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]
+  ) -> solana_program_entrypoint::ProgramResult {
     let mut accounts = Vec::with_capacity({{ instruction.accounts.length + '+' if instruction.accounts.length > 0}} remaining_accounts.len());
     {% for account in instruction.accounts %}
       {% if account.isSigner === 'either' %}
         {% if account.isOptional and instruction.optionalAccountStrategy === 'programId' %}
           if let Some(({{ account.name | snakeCase }}, signer)) = self.{{ account.name | snakeCase }} {
-            accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
               *{{ account.name | snakeCase }}.key,
               signer,
             ));
           } else {
-            accounts.push(solana_program::instruction::AccountMeta::new_readonly(
+            accounts.push(solana_instruction::AccountMeta::new_readonly(
               crate::{{ program.name | snakeCase | upper }}_ID,
               false,
             ));
           }
         {% elif account.isOptional %}
           if let Some(({{ account.name | snakeCase }}, signer)) = self.{{ account.name | snakeCase }} {
-            accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
               *{{ account.name | snakeCase }}.key,
               signer,
             ));
           }
         {% else %}
-          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+          accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
             *self.{{ account.name | snakeCase }}.0.key,
             self.{{ account.name | snakeCase }}.1,
           ));
@@ -119,25 +119,25 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
       {% else %}
         {% if account.isOptional and instruction.optionalAccountStrategy === 'programId' %}
           if let Some({{ account.name | snakeCase }}) = self.{{ account.name | snakeCase }} {
-            accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
               *{{ account.name | snakeCase }}.key,
               {{ 'true' if account.isSigner else 'false' }},
             ));
           } else {
-            accounts.push(solana_program::instruction::AccountMeta::new_readonly(
+            accounts.push(solana_instruction::AccountMeta::new_readonly(
               crate::{{ program.name | snakeCase | upper }}_ID,
               false,
             ));
           }
         {% elif account.isOptional %}
           if let Some({{ account.name | snakeCase }}) = self.{{ account.name | snakeCase }} {
-            accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
               *{{ account.name | snakeCase }}.key,
               {{ 'true' if account.isSigner else 'false' }},
             ));
           }
         {% else %}
-          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+          accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
             *self.{{ account.name | snakeCase }}.key,
             {{ 'true' if account.isSigner else 'false' }}
           ));
@@ -145,7 +145,7 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
       {% endif %}
     {% endfor %}
     remaining_accounts.iter().for_each(|remaining_account| {
-      accounts.push(solana_program::instruction::AccountMeta {
+      accounts.push(solana_instruction::AccountMeta {
           pubkey: *remaining_account.0.key,
           is_signer: remaining_account.1,
           is_writable: remaining_account.2,
@@ -157,7 +157,7 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
       data.append(&mut args);
     {% endif %}
 
-    let instruction = solana_program::instruction::Instruction {
+    let instruction = solana_instruction::Instruction {
       program_id: crate::{{ program.name | snakeCase | upper }}_ID,
       accounts,
       data,
@@ -176,9 +176,9 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}Cpi<'a, 'b> {
     remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
 
     if signers_seeds.is_empty() {
-      solana_program::program::invoke(&instruction, &account_infos)
+      solana_cpi::invoke(&instruction, &account_infos)
     } else {
-      solana_program::program::invoke_signed(&instruction, &account_infos, signers_seeds)
+      solana_cpi::invoke_signed(&instruction, &account_infos, signers_seeds)
     }
   }
 }

package/dist/templates/instructionsCpiPageBuilder.njk

@@ -21,7 +21,7 @@ pub struct {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
 }
 
 impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
-  pub fn new(program: &'b solana_program::account_info::AccountInfo<'a>) -> Self {
+  pub fn new(program: &'b solana_account_info::AccountInfo<'a>) -> Self {
     let instruction = Box::new({{ instruction.name | pascalCase }}CpiBuilderInstruction {
       __program: program,
       {% for account in instruction.accounts %}
@@ -40,7 +40,7 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
     {{'/// `[optional account]`\n' if account.isOptional }}
     {{- macros.docblock(account.docs) -}}
     #[inline(always)]
-    pub fn {{ account.name | snakeCase }}(&mut self, {{ account.name | snakeCase }}: {{ "Option<&'b solana_program::account_info::AccountInfo<'a>>" if account.isOptional else "&'b solana_program::account_info::AccountInfo<'a>" }}{{ ', as_signer: bool' if account.isSigner === 'either' }}) -> &mut Self {
+    pub fn {{ account.name | snakeCase }}(&mut self, {{ account.name | snakeCase }}: {{ "Option<&'b solana_account_info::AccountInfo<'a>>" if account.isOptional else "&'b solana_account_info::AccountInfo<'a>" }}{{ ', as_signer: bool' if account.isSigner === 'either' }}) -> &mut Self {
       {% if account.isOptional %}
         {% if account.isSigner === 'either' %}
           if let Some({{ account.name | snakeCase }}) = {{ account.name | snakeCase }} {
@@ -75,7 +75,7 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
   {% endfor %}
   /// Add an additional account to the instruction.
   #[inline(always)]
-  pub fn add_remaining_account(&mut self, account: &'b solana_program::account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
+  pub fn add_remaining_account(&mut self, account: &'b solana_account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
     self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
     self
   }
@@ -84,17 +84,17 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
   /// Each account is represented by a tuple of the `AccountInfo`, a `bool` indicating whether the account is writable or not,
   /// and a `bool` indicating whether the account is a signer or not.
   #[inline(always)]
-  pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
+  pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
     self.instruction.__remaining_accounts.extend_from_slice(accounts);
     self
   }
   #[inline(always)]
-  pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
+  pub fn invoke(&self) -> solana_program_entrypoint::ProgramResult {
     self.invoke_signed(&[])
   }
   #[allow(clippy::clone_on_copy)]
   #[allow(clippy::vec_init_then_push)]
-  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program::entrypoint::ProgramResult {
+  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_entrypoint::ProgramResult {
     {% if hasArgs %}
       let args = {{ instruction.name | pascalCase }}InstructionArgs {
         {% for arg in instructionArgs %}
@@ -127,12 +127,12 @@ impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
 
 #[derive(Clone, Debug)]
 struct {{ instruction.name | pascalCase }}CpiBuilderInstruction<'a, 'b> {
-  __program: &'b solana_program::account_info::AccountInfo<'a>,
+  __program: &'b solana_account_info::AccountInfo<'a>,
   {% for account in instruction.accounts %}
     {% if account.isSigner === 'either' %}
-      {{ account.name | snakeCase }}: Option<(&'b solana_program::account_info::AccountInfo<'a>, bool)>,
+      {{ account.name | snakeCase }}: Option<(&'b solana_account_info::AccountInfo<'a>, bool)>,
     {% else %}
-      {{ account.name | snakeCase }}: Option<&'b solana_program::account_info::AccountInfo<'a>>,
+      {{ account.name | snakeCase }}: Option<&'b solana_account_info::AccountInfo<'a>>,
     {% endif %}
   {% endfor %}
   {% for arg in instructionArgs %}
@@ -141,5 +141,5 @@ struct {{ instruction.name | pascalCase }}CpiBuilderInstruction<'a, 'b> {
     {% endif %}
   {% endfor %}
   /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
-  __remaining_accounts: Vec<(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)>,
+  __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
 }

package/dist/templates/instructionsPage.njk

@@ -14,9 +14,9 @@ pub struct {{ instruction.name | pascalCase }} {
     {% endif %}
 
     {% if account.isSigner === 'either' %}
-      {% set type = '(solana_program::pubkey::Pubkey, bool)' %}
+      {% set type = '(solana_pubkey::Pubkey, bool)' %}
     {% else %}
-      {% set type = 'solana_program::pubkey::Pubkey' %}
+      {% set type = 'solana_pubkey::Pubkey' %}
     {% endif %}
 
     {% if account.isOptional %}
@@ -28,38 +28,38 @@ pub struct {{ instruction.name | pascalCase }} {
 }
 
 impl {{ instruction.name | pascalCase }} {
-  pub fn instruction(&self{{ ', args: ' + instruction.name | pascalCase + 'InstructionArgs' if hasArgs }}) -> solana_program::instruction::Instruction {
+  pub fn instruction(&self{{ ', args: ' + instruction.name | pascalCase + 'InstructionArgs' if hasArgs }}) -> solana_instruction::Instruction {
     self.instruction_with_remaining_accounts({{ 'args, ' if hasArgs }}&[])
   }
   #[allow(clippy::arithmetic_side_effects)]
   #[allow(clippy::vec_init_then_push)]
-  pub fn instruction_with_remaining_accounts(&self{{ ', args: ' + instruction.name | pascalCase + 'InstructionArgs' if hasArgs }}, remaining_accounts: &[solana_program::instruction::AccountMeta]) -> solana_program::instruction::Instruction {
+  pub fn instruction_with_remaining_accounts(&self{{ ', args: ' + instruction.name | pascalCase + 'InstructionArgs' if hasArgs }}, remaining_accounts: &[solana_instruction::AccountMeta]) -> solana_instruction::Instruction {
     let mut accounts = Vec::with_capacity({{ instruction.accounts.length + '+' if instruction.accounts.length > 0}} remaining_accounts.len());
     {% for account in instruction.accounts %}
       {% if account.isSigner === 'either' %}
         {% if account.isOptional %}
           {% if instruction.optionalAccountStrategy === 'programId' %}
             if let Some(({{ account.name | snakeCase }}, signer)) = self.{{ account.name | snakeCase }} {
-              accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+              accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
                 {{ account.name | snakeCase }},
                 signer,
               ));
             } else {
-              accounts.push(solana_program::instruction::AccountMeta::new_readonly(
+              accounts.push(solana_instruction::AccountMeta::new_readonly(
                 crate::{{ program.name | snakeCase | upper }}_ID,
                 false,
               ));
             }
           {% else %}
             if let Some(({{ account.name | snakeCase }}, signer)) = self.{{ account.name | snakeCase }} {
-              accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+              accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
                 {{ account.name | snakeCase }},
                 signer,
               ));
             }
           {% endif %}
         {% else %}
-          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+          accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
             self.{{ account.name | snakeCase }}.0,
             self.{{ account.name | snakeCase }}.1,
           ));
@@ -68,26 +68,26 @@ impl {{ instruction.name | pascalCase }} {
         {% if account.isOptional %}
           {% if instruction.optionalAccountStrategy === 'programId' %}
             if let Some({{ account.name | snakeCase }}) = self.{{ account.name | snakeCase }} {
-              accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+              accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
                 {{ account.name | snakeCase }},
                 {{ 'true' if account.isSigner else 'false' }},
               ));
             } else {
-              accounts.push(solana_program::instruction::AccountMeta::new_readonly(
+              accounts.push(solana_instruction::AccountMeta::new_readonly(
                 crate::{{ program.name | snakeCase | upper }}_ID,
                 false,
               ));
             }
           {% elif account.isOptional %}
             if let Some({{ account.name | snakeCase }}) = self.{{ account.name | snakeCase }} {
-              accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+              accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
                 {{ account.name | snakeCase }},
                 {{ 'true' if account.isSigner else 'false' }},
               ));
             }
           {% endif %}
         {% else %}
-          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+          accounts.push(solana_instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
             self.{{ account.name | snakeCase }},
             {{ 'true' if account.isSigner else 'false' }}
           ));
@@ -101,7 +101,7 @@ impl {{ instruction.name | pascalCase }} {
       data.append(&mut args);
     {% endif %}
 
-    solana_program::instruction::Instruction {
+    solana_instruction::Instruction {
       program_id: crate::{{ program.name | snakeCase | upper }}_ID,
       accounts,
       data,

package/dist/templates/instructionsPageBuilder.njk

@@ -20,9 +20,9 @@
 pub struct {{ instruction.name | pascalCase }}Builder {
   {% for account in instruction.accounts %}
     {% if account.isSigner === 'either' %}
-      {{ account.name | snakeCase }}: Option<(solana_program::pubkey::Pubkey, bool)>,
+      {{ account.name | snakeCase }}: Option<(solana_pubkey::Pubkey, bool)>,
     {% else %}
-      {{ account.name | snakeCase }}: Option<solana_program::pubkey::Pubkey>,
+      {{ account.name | snakeCase }}: Option<solana_pubkey::Pubkey>,
     {% endif %}
   {% endfor %}
   {% for arg in instructionArgs %}
@@ -30,7 +30,7 @@ pub struct {{ instruction.name | pascalCase }}Builder {
       {{ arg.name | snakeCase }}: {{ arg.type if arg.innerOptionType else 'Option<' + arg.type + '>' }},
     {% endif %}
   {% endfor %}
-  __remaining_accounts: Vec<solana_program::instruction::AccountMeta>,
+  __remaining_accounts: Vec<solana_instruction::AccountMeta>,
 }
 
 impl {{ instruction.name | pascalCase }}Builder {
@@ -45,7 +45,7 @@ impl {{ instruction.name | pascalCase }}Builder {
     {% endif %}
     {{- macros.docblock(account.docs) -}}
     #[inline(always)]
-    pub fn {{ account.name | snakeCase }}(&mut self, {{ account.name | snakeCase }}: {{ 'Option<solana_program::pubkey::Pubkey>' if account.isOptional else 'solana_program::pubkey::Pubkey' }}{{ ', as_signer: bool' if account.isSigner === 'either' }}) -> &mut Self {
+    pub fn {{ account.name | snakeCase }}(&mut self, {{ account.name | snakeCase }}: {{ 'Option<solana_pubkey::Pubkey>' if account.isOptional else 'solana_pubkey::Pubkey' }}{{ ', as_signer: bool' if account.isSigner === 'either' }}) -> &mut Self {
       {% if account.isOptional %}
         {% if account.isSigner === 'either' %}
           if let Some({{ account.name | snakeCase }}) = {{ account.name | snakeCase }} {
@@ -80,18 +80,18 @@ impl {{ instruction.name | pascalCase }}Builder {
   {% endfor %}
   /// Add an additional account to the instruction.
   #[inline(always)]
-  pub fn add_remaining_account(&mut self, account: solana_program::instruction::AccountMeta) -> &mut Self {
+  pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
     self.__remaining_accounts.push(account);
     self
   }
   /// Add additional accounts to the instruction.
   #[inline(always)]
-  pub fn add_remaining_accounts(&mut self, accounts: &[solana_program::instruction::AccountMeta]) -> &mut Self {
+  pub fn add_remaining_accounts(&mut self, accounts: &[solana_instruction::AccountMeta]) -> &mut Self {
     self.__remaining_accounts.extend_from_slice(accounts);
     self
   }
   #[allow(clippy::clone_on_copy)]
-  pub fn instruction(&self) -> solana_program::instruction::Instruction {
+  pub fn instruction(&self) -> solana_instruction::Instruction {
     let accounts = {{ instruction.name | pascalCase }} {
         {% for account in instruction.accounts %}
           {% if account.isOptional %}
@@ -99,7 +99,7 @@ impl {{ instruction.name | pascalCase }}Builder {
           {% elif account.defaultValue.kind === 'programId' %}
             {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }}, {# Program ID set on the instruction creation. #}
           {% elif account.defaultValue.kind === 'publicKeyValueNode' %}
-            {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }}.unwrap_or(solana_program::pubkey!("{{ account.defaultValue.publicKey }}")),
+            {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }}.unwrap_or(solana_pubkey::pubkey!("{{ account.defaultValue.publicKey }}")),
           {% else %}
             {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }}.expect("{{ account.name | snakeCase }} is not set"),
           {% endif %}

package/dist/templates/programsMod.njk

@@ -2,7 +2,7 @@
 
 {% block main %}
 
-use solana_program::{pubkey, pubkey::Pubkey};
+use solana_pubkey::{pubkey, Pubkey};
 
 {% for program in programsToExport | sort(false, false, 'name') %}
 

package/dist/templates/sharedPage.njk

@@ -16,8 +16,8 @@ For now, we just define them here. This the following caveat:
     #[cfg(feature = "fetch")]
     #[derive(Debug, Clone)]
     pub struct DecodedAccount<T> {
-        pub address: solana_program::pubkey::Pubkey,
-        pub account: solana_sdk::account::Account,
+        pub address: solana_pubkey::Pubkey,
+        pub account: solana_account::Account,
         pub data: T,
     }
 
@@ -25,7 +25,7 @@ For now, we just define them here. This the following caveat:
     #[derive(Debug, Clone)]
     pub enum MaybeAccount<T> {
         Exists(DecodedAccount<T>),
-        NotFound(solana_program::pubkey::Pubkey),
+        NotFound(solana_pubkey::Pubkey),
     }
 
 {% endif %}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codama/renderers-rust",
-  "version": "1.0.21",
+  "version": "1.1.0",
   "description": "Renders Rust clients for your programs",
   "exports": {
     "types": "./dist/types/index.d.ts",
@@ -30,14 +30,14 @@
   "dependencies": {
     "@solana/codecs-strings": "rc",
     "nunjucks": "^3.2.4",
-    "@codama/errors": "1.2.13",
-    "@codama/nodes": "1.2.13",
-    "@codama/renderers-core": "1.0.15",
-    "@codama/visitors-core": "1.2.13"
+    "@codama/errors": "1.3.0",
+    "@codama/nodes": "1.3.0",
+    "@codama/renderers-core": "1.0.16",
+    "@codama/visitors-core": "1.3.0"
   },
   "devDependencies": {
     "@types/nunjucks": "^3.2.6",
-    "@codama/nodes-from-anchor": "1.1.13"
+    "@codama/nodes-from-anchor": "1.2.1"
   },
   "license": "MIT",
   "repository": {