@codama/renderers-rust 1.0.0

package/dist/templates/instructionsCpiPageBuilder.njk

@@ -0,0 +1,145 @@
+/// Instruction builder for `{{ instruction.name | pascalCase }}` via CPI.
+///
+/// ### Accounts:
+///
+{% for account in instruction.accounts %}
+  {% set modifiers = '' %}
+  {% if account.isWritable %}
+    {% set modifiers = 'writable' %}
+  {% endif %}
+  {% if account.isSigner %}
+    {% set modifiers = modifiers + ', signer' if modifiers.length > 0 else 'signer' %}
+  {% endif %}
+  {% if account.isOptional %}
+    {% set modifiers = modifiers + ', optional' if modifiers.length > 0 else 'optional' %}
+  {% endif %}
+  {{ '///   ' + loop.index0 + '. `[' + modifiers + ']` ' + account.name | snakeCase }}
+{% endfor %}
+#[derive(Clone, Debug)]
+pub struct {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
+  instruction: Box<{{ instruction.name | pascalCase }}CpiBuilderInstruction<'a, 'b>>,
+}
+
+impl<'a, 'b> {{ instruction.name | pascalCase }}CpiBuilder<'a, 'b> {
+  pub fn new(program: &'b solana_program::account_info::AccountInfo<'a>) -> Self {
+    let instruction = Box::new({{ instruction.name | pascalCase }}CpiBuilderInstruction {
+      __program: program,
+      {% for account in instruction.accounts %}
+        {{ account.name | snakeCase }}: None,
+      {% endfor %}
+      {% for arg in instructionArgs %}
+        {% if not arg.default %}
+          {{ arg.name | snakeCase }}: None,
+        {% endif %}
+      {% endfor %}
+      __remaining_accounts: Vec::new(),
+    });
+    Self { instruction }
+  }
+  {% for account in instruction.accounts %}
+    {{'/// `[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 {
+      {% if account.isOptional %}
+        {% if account.isSigner === 'either' %}
+          if let Some({{ account.name | snakeCase }}) = {{ account.name | snakeCase }} {
+            self.instruction.{{ account.name | snakeCase }} = Some(({{ account.name | snakeCase }}, as_signer));
+          } else {
+            self.instruction.{{ account.name | snakeCase }} = None;
+          }
+        {% else %}
+          self.instruction.{{ account.name | snakeCase }} = {{ account.name | snakeCase }};
+        {% endif %}
+      {% else %}
+        {% if account.isSigner === 'either' %}
+          self.instruction.{{ account.name | snakeCase }} = Some(({{ account.name | snakeCase }}, as_signer));
+        {% else %}
+          self.instruction.{{ account.name | snakeCase }} = Some({{ account.name | snakeCase }});
+        {% endif %}
+      {% endif %}
+      self
+    }
+  {% endfor %}
+  {% for arg in instructionArgs %}
+    {% if not arg.default %}
+      {{'/// `[optional argument]`\n' if arg.innerOptionType }}
+      {{- "/// `[optional argument, defaults to '" + arg.value + "']`\n" if not arg.innerOptionType and arg.value -}}
+      {{- macros.docblock(arg.docs) -}}
+      #[inline(always)]
+      pub fn {{ arg.name | snakeCase }}(&mut self, {{ arg.name | snakeCase }}: {{ arg.innerOptionType or arg.type }}) -> &mut Self {
+        self.instruction.{{ arg.name | snakeCase }} = Some({{ arg.name | snakeCase }});
+        self
+      }
+    {% endif %}
+  {% 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 {
+    self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
+    self
+  }
+  /// Add additional accounts to the instruction.
+  ///
+  /// 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 {
+    self.instruction.__remaining_accounts.extend_from_slice(accounts);
+    self
+  }
+  #[inline(always)]
+  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 {
+    {% if hasArgs %}
+      let args = {{ instruction.name | pascalCase }}InstructionArgs {
+        {% for arg in instructionArgs %}
+          {% if not arg.default %}
+            {% if arg.optional %}
+              {% if arg.innerOptionType %}
+                {{ arg.name | snakeCase }}: self.instruction.{{ arg.name | snakeCase }}.clone(),
+              {% else %}
+                {{ arg.name | snakeCase }}: self.instruction.{{ arg.name | snakeCase }}.clone(){{ '.unwrap_or(' + arg.value + ')' if arg.value else '.expect(\"' + arg.name | snakeCase + ' is not set\")' }},
+              {% endif %}
+            {% else %}
+              {{ arg.name | snakeCase }}: self.instruction.{{ arg.name | snakeCase }}.clone(){{ '.expect(\"' + arg.name | snakeCase + ' is not set\")' if not arg.innerOptionType }},
+            {% endif %}
+          {% endif %}
+        {% endfor %}
+      };
+    {% endif %}
+    let instruction = {{ instruction.name | pascalCase }}Cpi {
+        __program: self.instruction.__program,
+        {% for account in instruction.accounts %}          
+          {{ account.name | snakeCase }}: self.instruction.{{ account.name | snakeCase }}{{ '.expect(\"' + account.name | snakeCase + ' is not set\")' if not account.isOptional }},
+        {% endfor %}
+        {% if hasArgs %}
+          __args: args,
+        {% endif %}
+    };
+    instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
+  }
+}
+
+#[derive(Clone, Debug)]
+struct {{ instruction.name | pascalCase }}CpiBuilderInstruction<'a, 'b> {
+  __program: &'b solana_program::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)>,
+    {% else %}
+      {{ account.name | snakeCase }}: Option<&'b solana_program::account_info::AccountInfo<'a>>,
+    {% endif %}
+  {% endfor %}
+  {% for arg in instructionArgs %}
+    {% if not arg.default %}
+      {{ arg.name | snakeCase }}: {{ arg.type if arg.innerOptionType else 'Option<' + arg.type + '>' }},
+    {% endif %}
+  {% endfor %}
+  /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
+  __remaining_accounts: Vec<(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)>,
+}

package/dist/templates/instructionsMod.njk

@@ -0,0 +1,13 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+
+{% for instruction in instructionsToExport | sort(false, false, 'name') %}
+  pub(crate) mod r#{{ instruction.name | snakeCase }};
+{% endfor %}
+
+{% for instruction in instructionsToExport | sort(false, false, 'name') %}
+  pub use self::r#{{ instruction.name | snakeCase }}::*;
+{% endfor %}
+
+{% endblock %}

package/dist/templates/instructionsPage.njk

@@ -0,0 +1,159 @@
+{% extends "layout.njk" %}
+{% import "macros.njk" as macros %}
+
+{% block main %}
+
+{{ imports }}
+
+/// Accounts.
+pub struct {{ instruction.name | pascalCase }} {
+  {% for account in instruction.accounts %}
+    {% if account.docs.length > 0 %}
+      {{ macros.docblock(account.docs) }}
+    {% endif %}
+
+    {% if account.isSigner === 'either' %}
+      {% set type = '(solana_program::pubkey::Pubkey, bool)' %}
+    {% else %}
+      {% set type = 'solana_program::pubkey::Pubkey' %}
+    {% endif %}
+
+    {% if account.isOptional %}
+      pub {{ account.name | snakeCase }}: Option<{{ type }}>,
+    {% else %}
+      pub {{ account.name | snakeCase }}: {{ type }},
+    {% endif %}
+  {% endfor %}
+}
+
+impl {{ instruction.name | pascalCase }} {
+  pub fn instruction(&self{{ ', args: ' + instruction.name | pascalCase + 'InstructionArgs' if hasArgs }}) -> solana_program::instruction::Instruction {
+    self.instruction_with_remaining_accounts({{ 'args, ' if hasArgs }}&[])
+  }
+  #[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 {
+    let mut accounts = Vec::with_capacity({{ instruction.accounts.length }} + 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' }}(
+                {{ account.name | snakeCase }},
+                signer,
+              ));
+            } else {
+              accounts.push(solana_program::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' }}(
+                {{ account.name | snakeCase }},
+                signer,
+              ));
+            }
+          {% endif %}
+        {% else %}
+          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            self.{{ account.name | snakeCase }}.0,
+            self.{{ account.name | snakeCase }}.1,
+          ));
+        {% endif %}
+      {% else %}
+        {% 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' }}(
+                {{ account.name | snakeCase }},
+                {{ 'true' if account.isSigner else 'false' }},
+              ));
+            } else {
+              accounts.push(solana_program::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' }}(
+                {{ account.name | snakeCase }},
+                {{ 'true' if account.isSigner else 'false' }},
+              ));
+            }
+          {% endif %}
+        {% else %}
+          accounts.push(solana_program::instruction::AccountMeta::{{ 'new' if account.isWritable else 'new_readonly' }}(
+            self.{{ account.name | snakeCase }},
+            {{ 'true' if account.isSigner else 'false' }}
+          ));
+        {% endif %}
+      {% endif %}
+    {% endfor %}
+    accounts.extend_from_slice(remaining_accounts);
+    let {{ 'mut ' if hasArgs }}data = {{ instruction.name | pascalCase }}InstructionData::new().try_to_vec().unwrap();
+    {% if hasArgs %}
+      let mut args = args.try_to_vec().unwrap();
+      data.append(&mut args);
+    {% endif %}
+
+    solana_program::instruction::Instruction {
+      program_id: crate::{{ program.name | snakeCase | upper }}_ID,
+      accounts,
+      data,
+    }
+  }
+}
+
+#[derive(BorshDeserialize, BorshSerialize)]
+pub struct {{ instruction.name | pascalCase }}InstructionData {
+  {% for arg in instructionArgs %}
+    {% if arg.default %}
+      {{ arg.name | snakeCase }}: {{ arg.type }},
+    {% endif %}
+  {% endfor %}
+}
+
+impl {{ instruction.name | pascalCase }}InstructionData {
+  pub fn new() -> Self {
+    Self {
+      {% for arg in instructionArgs %}
+        {% if arg.default %}
+          {{ arg.name | snakeCase }}: {{ arg.value }},
+        {% endif %}
+      {% endfor %}
+    }
+  }
+}
+
+impl Default for {{ instruction.name | pascalCase }}InstructionData {
+  fn default() -> Self {
+    Self::new()
+  }
+}
+
+{% if hasArgs %}
+#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct {{ instruction.name | pascalCase }}InstructionArgs {
+  {% for arg in instructionArgs %}
+    {% if not arg.default %}
+      pub {{ arg.name | snakeCase }}: {{ arg.type }},
+    {% endif %}
+  {% endfor %}
+}
+{% endif %}
+
+{% for nestedStruct in typeManifest.nestedStructs %}
+#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+{{ nestedStruct }}
+{% endfor %}
+
+{% include "instructionsPageBuilder.njk" %}
+
+{% include "instructionsCpiPage.njk" %}
+
+{% endblock %}

package/dist/templates/instructionsPageBuilder.njk

@@ -0,0 +1,128 @@
+/// Instruction builder for `{{ instruction.name | pascalCase }}`.
+///
+/// ### Accounts:
+///
+{% for account in instruction.accounts %}
+  {% set modifiers = '' %}
+  {% if account.isWritable %}
+    {% set modifiers = 'writable' %}
+  {% endif %}
+  {% if account.isSigner %}
+    {% set modifiers = modifiers + ', signer' if modifiers.length > 0 else 'signer' %}
+  {% endif %}
+  {% if account.isOptional or account.defaultValue.kind === 'publicKeyValueNode' %}
+    {% set modifiers = modifiers + ', optional' if modifiers.length > 0 else 'optional' %}
+  {% endif %}
+  {{ '///   ' + loop.index0 + '. `[' + modifiers + ']` ' + account.name | snakeCase }}
+  {{- " (default to `" + account.defaultValue.publicKey + "`)" if account.defaultValue.kind === 'publicKeyValueNode' }}
+{% endfor %}
+#[derive(Clone, Debug, Default)]
+pub struct {{ instruction.name | pascalCase }}Builder {
+  {% for account in instruction.accounts %}
+    {% if account.isSigner === 'either' %}
+      {{ account.name | snakeCase }}: Option<(solana_program::pubkey::Pubkey, bool)>,
+    {% else %}
+      {{ account.name | snakeCase }}: Option<solana_program::pubkey::Pubkey>,
+    {% endif %}
+  {% endfor %}
+  {% for arg in instructionArgs %}
+    {% if not arg.default %}
+      {{ arg.name | snakeCase }}: {{ arg.type if arg.innerOptionType else 'Option<' + arg.type + '>' }},
+    {% endif %}
+  {% endfor %}
+  __remaining_accounts: Vec<solana_program::instruction::AccountMeta>,
+}
+
+impl {{ instruction.name | pascalCase }}Builder {
+  pub fn new() -> Self {
+    Self::default()
+  }
+  {% for account in instruction.accounts %}
+    {% if account.isOptional %}
+      {{ '/// `[optional account]`\n' -}}
+    {% else %}
+      {{ "/// `[optional account, default to '" + account.defaultValue.publicKey + "']`\n" if account.defaultValue.kind === 'publicKeyValueNode' -}}
+    {% 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 {
+      {% if account.isOptional %}
+        {% if account.isSigner === 'either' %}
+          if let Some({{ account.name | snakeCase }}) = {{ account.name | snakeCase }} {
+            self.{{ account.name | snakeCase }} = Some(({{ account.name | snakeCase }}, as_signer));
+          } else {
+            self.{{ account.name | snakeCase }} = None;
+          }
+        {% else %}
+          self.{{ account.name | snakeCase }} = {{ account.name | snakeCase }};
+        {% endif %}
+      {% else %}
+        {% if account.isSigner === 'either' %}
+          self.{{ account.name | snakeCase }} = Some(({{ account.name | snakeCase }}, as_signer));
+        {% else %}
+          self.{{ account.name | snakeCase }} = Some({{ account.name | snakeCase }});
+        {% endif %}
+      {% endif %}
+      self
+    }
+  {% endfor %}
+  {% for arg in instructionArgs %}
+    {% if not arg.default %}
+      {{ '/// `[optional argument]`\n' if arg.innerOptionType }}
+      {{- "/// `[optional argument, defaults to '" + arg.value + "']`\n" if not arg.innerOptionType and arg.value -}}
+      {{- macros.docblock(arg.docs) -}}
+      #[inline(always)]
+      pub fn {{ arg.name | snakeCase }}(&mut self, {{ arg.name | snakeCase }}: {{ arg.innerOptionType or arg.type }}) -> &mut Self {
+        self.{{ arg.name | snakeCase }} = Some({{ arg.name | snakeCase }});
+        self
+      }
+    {% endif %}
+  {% endfor %}
+  /// Add an additional account to the instruction.
+  #[inline(always)]
+  pub fn add_remaining_account(&mut self, account: solana_program::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 {
+    self.__remaining_accounts.extend_from_slice(accounts);
+    self
+  }
+  #[allow(clippy::clone_on_copy)]
+  pub fn instruction(&self) -> solana_program::instruction::Instruction {
+    let accounts = {{ instruction.name | pascalCase }} {
+        {% for account in instruction.accounts %}
+          {% if account.isOptional %}
+            {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }},
+          {% 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 }}")),
+          {% else %}
+            {{ account.name | snakeCase }}: self.{{ account.name | snakeCase }}.expect("{{ account.name | snakeCase }} is not set"),
+          {% endif %}
+        {% endfor %}
+    };
+    {% if hasArgs %}
+      let args = {{ instruction.name | pascalCase }}InstructionArgs {
+        {% for arg in instructionArgs %}
+          {% if not arg.default %}
+            {% if arg.optional %}
+              {% if arg.innerOptionType %}
+                {{ arg.name | snakeCase }}: self.{{ arg.name | snakeCase }}.clone(),
+              {% else %}
+                {{ arg.name | snakeCase }}: self.{{ arg.name | snakeCase }}.clone(){{ '.unwrap_or(' + arg.value + ')' if arg.value else '.expect(\"' + arg.name | snakeCase + ' is not set\")' }},
+              {% endif %}
+            {% else %}
+              {{ arg.name | snakeCase }}: self.{{ arg.name | snakeCase }}.clone(){{ '.expect(\"' + arg.name | snakeCase + ' is not set\")' if not arg.innerOptionType }},
+            {% endif %}
+          {% endif %}
+        {% endfor %}
+      };
+    {% endif %}
+
+    accounts.instruction_with_remaining_accounts({{ 'args, ' if hasArgs }}&self.__remaining_accounts)
+  }
+}

package/dist/templates/layout.njk

@@ -0,0 +1,7 @@
+//! This code was AUTOGENERATED using the codama library.
+//! Please DO NOT EDIT THIS FILE, instead use visitors
+//! to add features, then rerun codama to update it.
+//!
+//! <https://github.com/codama-idl/codama>
+//!
+{% block main %}{% endblock %}

package/dist/templates/macros.njk

@@ -0,0 +1,6 @@
+{# Write a docblock from an array of strings. #}
+{% macro docblock(docs) %}
+{% for doc in docs %}
+/// {{ doc }}
+{% endfor %}
+{% endmacro %}

package/dist/templates/programsMod.njk

@@ -0,0 +1,13 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+
+use solana_program::{pubkey, pubkey::Pubkey};
+
+{% for program in programsToExport | sort(false, false, 'name') %}
+
+  /// `{{ program.name | snakeCase }}` program ID.
+  pub const {{ program.name | snakeCase | upper }}_ID: Pubkey = pubkey!("{{ program.publicKey }}");
+{% endfor %}
+
+{% endblock %}

package/dist/templates/rootMod.njk

@@ -0,0 +1,26 @@
+{% extends "layout.njk" %}
+
+{% block main %}
+
+{% if hasAnythingToExport %}
+  {% if accountsToExport.length > 0 %}
+    pub mod accounts;
+  {% endif %}
+  {% if programsToExport.length > 0 %}
+    pub mod errors;
+  {% endif %}
+  {% if instructionsToExport.length > 0 %}
+    pub mod instructions;
+  {% endif %}
+  {% if programsToExport.length > 0 %}
+    pub mod programs;
+  {% endif %}
+  {% if definedTypesToExport.length > 0 %}
+    pub mod types;
+  {% endif %}
+{% endif %}
+
+{% if programsToExport.length > 0 %}
+  pub(crate) use programs::*;
+{% endif %}
+{% endblock %}

package/dist/templates/sharedPage.njk

@@ -0,0 +1,93 @@
+{% extends "layout.njk" %}
+{% block main %}
+
+use std::fmt::Debug;
+use std::io::Write;
+use std::ops::{Deref, DerefMut};
+
+use borsh::maybestd::io::Read;
+use borsh::{BorshDeserialize, BorshSerialize};
+
+/// A vector that deserializes from a stream of bytes.
+///
+/// This is useful for deserializing a vector that does not have
+/// a length prefix. In order to determine how many elements to deserialize,
+/// the type of the elements must implement the trait `Sized`.
+pub struct RemainderVec<T: BorshSerialize + BorshDeserialize>(Vec<T>);
+
+/// Deferences the inner `Vec` type.
+impl<T> Deref for RemainderVec<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    type Target = Vec<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// Deferences the inner `Vec` type as mutable.
+impl<T> DerefMut for RemainderVec<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// `Debug` implementation for `RemainderVec`.
+///
+/// This implementation simply forwards to the inner `Vec` type.
+impl<T> Debug for RemainderVec<T>
+where
+    T: BorshSerialize + BorshDeserialize + Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{:?}", self.0))
+    }
+}
+
+impl<T> BorshDeserialize for RemainderVec<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    fn deserialize_reader<R: Read>(reader: &mut R) -> borsh::maybestd::io::Result<Self> {
+        let length = std::mem::size_of::<T>();
+        // buffer to read the data
+        let mut buffer = vec![0u8; length];
+        // vec to store the items
+        let mut items: Vec<T> = Vec::new();
+
+        loop {
+            match reader.read(&mut buffer)? {
+                0 => break,
+                n if n == length => items.push(T::deserialize(&mut buffer.as_slice())?),
+                e => {
+                    return Err(borsh::maybestd::io::Error::new(
+                        borsh::maybestd::io::ErrorKind::InvalidData,
+                        format!("unexpected number of bytes (read {e}, expected {length})"),
+                    ))
+                }
+            }
+        }
+
+        Ok(Self(items))
+    }
+}
+
+impl<T> BorshSerialize for RemainderVec<T>
+where
+    T: BorshSerialize + BorshDeserialize,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> borsh::maybestd::io::Result<()> {
+        // serialize each item without adding a prefix for the length
+        for item in self.0.iter() {
+            item.serialize(writer)?;
+        }
+
+        Ok(())
+    }
+}
+{% endblock %}

package/dist/types/ImportMap.d.ts

@@ -0,0 +1,16 @@
+import { TypeManifest } from './getTypeManifestVisitor';
+export declare class ImportMap {
+    protected readonly _imports: Set<string>;
+    protected readonly _aliases: Map<string, string>;
+    get imports(): Set<string>;
+    get aliases(): Map<string, string>;
+    add(imports: Set<string> | string[] | string): ImportMap;
+    remove(imports: Set<string> | string[] | string): ImportMap;
+    mergeWith(...others: ImportMap[]): ImportMap;
+    mergeWithManifest(manifest: TypeManifest): ImportMap;
+    addAlias(importName: string, alias: string): ImportMap;
+    isEmpty(): boolean;
+    resolveDependencyMap(dependencies: Record<string, string>): ImportMap;
+    toString(dependencies: Record<string, string>): string;
+}
+//# sourceMappingURL=ImportMap.d.ts.map

package/dist/types/ImportMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportMap.d.ts","sourceRoot":"","sources":["../../src/ImportMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAaxD,qBAAa,SAAS;IAClB,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IAErD,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAa;IAE7D,IAAI,OAAO,IAAI,GAAG,CAAC,MAAM,CAAC,CAEzB;IAED,IAAI,OAAO,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEjC;IAED,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS;IAMxD,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS;IAM3D,SAAS,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,GAAG,SAAS;IAQ5C,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS;IAIpD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;IAKtD,OAAO,IAAI,OAAO;IAIlB,oBAAoB,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS;IAcrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM;CASzD"}

package/dist/types/getRenderMapVisitor.d.ts

@@ -0,0 +1,9 @@
+import { RenderMap } from '@codama/renderers-core';
+import { LinkOverrides } from './utils';
+export type GetRenderMapOptions = {
+    dependencyMap?: Record<string, string>;
+    linkOverrides?: LinkOverrides;
+    renderParentInstructions?: boolean;
+};
+export declare function getRenderMapVisitor(options?: GetRenderMapOptions): import("@codama/visitors-core").Visitor<RenderMap, "accountNode" | "definedTypeNode" | "instructionNode" | "programNode" | "rootNode">;
+//# sourceMappingURL=getRenderMapVisitor.d.ts.map

package/dist/types/getRenderMapVisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRenderMapVisitor.d.ts","sourceRoot":"","sources":["../../src/getRenderMapVisitor.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAanD,OAAO,EAAwB,aAAa,EAAU,MAAM,SAAS,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACtC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,mBAAwB,0IAqPpE"}

package/dist/types/getTypeManifestVisitor.d.ts

@@ -0,0 +1,13 @@
+import { ImportMap } from './ImportMap';
+import { GetImportFromFunction } from './utils';
+export type TypeManifest = {
+    imports: ImportMap;
+    nestedStructs: string[];
+    type: string;
+};
+export declare function getTypeManifestVisitor(options: {
+    getImportFrom: GetImportFromFunction;
+    nestedStruct?: boolean;
+    parentName?: string | null;
+}): import("@codama/visitors-core").Visitor<TypeManifest, "definedTypeLinkNode" | "accountNode" | "definedTypeNode" | "enumEmptyVariantTypeNode" | "enumStructVariantTypeNode" | "enumTupleVariantTypeNode" | "amountTypeNode" | "arrayTypeNode" | "booleanTypeNode" | "bytesTypeNode" | "dateTimeTypeNode" | "enumTypeNode" | "fixedSizeTypeNode" | "hiddenPrefixTypeNode" | "hiddenSuffixTypeNode" | "mapTypeNode" | "numberTypeNode" | "optionTypeNode" | "postOffsetTypeNode" | "preOffsetTypeNode" | "publicKeyTypeNode" | "remainderOptionTypeNode" | "sentinelTypeNode" | "setTypeNode" | "sizePrefixTypeNode" | "solAmountTypeNode" | "stringTypeNode" | "structTypeNode" | "tupleTypeNode" | "zeroableOptionTypeNode" | "structFieldTypeNode">;
+//# sourceMappingURL=getTypeManifestVisitor.d.ts.map

package/dist/types/getTypeManifestVisitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTypeManifestVisitor.d.ts","sourceRoot":"","sources":["../../src/getTypeManifestVisitor.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,qBAAqB,EAAgB,MAAM,SAAS,CAAC;AAE9D,MAAM,MAAM,YAAY,GAAG;IACvB,OAAO,EAAE,SAAS,CAAC;IACnB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC5C,aAAa,EAAE,qBAAqB,CAAC;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,utBAwcA"}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ImportMap';
+export * from './getRenderMapVisitor';
+export * from './getTypeManifestVisitor';
+export * from './renderVisitor';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC"}