Struct CodeBuilder 

pub struct CodeBuilder { /* private fields */ }

A builder for compiling account components, note scripts, and transaction scripts with optional library dependencies.

The CodeBuilder simplifies the process of creating transaction scripts by providing:

• A clean API for adding multiple libraries with static or dynamic linking
• Automatic assembler configuration with all added libraries
• Debug mode support
• Builder pattern support for method chaining

Static vs Dynamic Linking

Static Linking (link_static_library() / with_statically_linked_library()):

• Use when you control and know the library code
• The library code is copied into the script code
• Best for most user-written libraries and dependencies
• Results in larger script size but ensures the code is always available

Dynamic Linking (link_dynamic_library() / with_dynamically_linked_library()):

• Use when making Foreign Procedure Invocation (FPI) calls
• The library code is available on-chain and referenced, not copied
• Results in smaller script size but requires the code to be available on-chain

Typical Workflow

1. Create a new CodeBuilder with debug mode preference
2. Add any required modules using link_module() or with_linked_module()
3. Add libraries using link_static_library() / link_dynamic_library() as appropriate
4. Compile your script with compile_note_script() or compile_tx_script()

Note that the compiling methods consume the CodeBuilder, so if you need to compile multiple scripts with the same configuration, you should clone the builder first.

Builder Pattern Example

let script = CodeBuilder::default()
    .with_linked_module("my::module", module_code).context("failed to link module")?
    .with_statically_linked_library(&my_lib).context("failed to link static library")?
    .with_dynamically_linked_library(&fpi_lib).context("failed to link dynamic library")?  // For FPI calls
    .compile_tx_script(script_code).context("failed to parse tx script")?;

Note

The CodeBuilder automatically includes the miden and std libraries, which provide access to transaction kernel procedures. Due to being available on-chain these libraries are linked dynamically and do not add to the size of built script.

Implementations

impl CodeBuilder

pub fn new() -> Self

Creates a new CodeBuilder.

pub fn with_source_manager(source_manager: Arc<dyn SourceManagerSync>) -> Self

Creates a new CodeBuilder with the specified source manager.

Arguments

• source_manager - The source manager to use with the internal Assembler

pub fn link_module( &mut self, module_path: impl AsRef<str>, module_code: impl Parse, ) -> Result<(), CodeBuilderError>

Parses and links a module to the code builder.

This method compiles the provided module code and adds it directly to the assembler for use in script compilation.

Arguments

• module_path - The path identifier for the module (e.g., “my_lib::my_module”)
• module_code - The source code of the module to compile and link

Errors

Returns an error if:

• The module path is invalid
• The module code cannot be parsed
• The module cannot be assembled

pub fn link_static_library( &mut self, library: &Library, ) -> Result<(), CodeBuilderError>

Statically links the given library.

Static linking means the library code is copied into the script code. Use this for most libraries that are not available on-chain.

Arguments

• library - The compiled library to statically link

Errors

Returns an error if:

• adding the library to the assembler failed

pub fn link_dynamic_library( &mut self, library: &Library, ) -> Result<(), CodeBuilderError>

Dynamically links a library.

This is useful to dynamically link the Library of a foreign account that is invoked using foreign procedure invocation (FPI). Its code is available on-chain and so it does not have to be copied into the script code.

For all other use cases not involving FPI, link the library statically.

Arguments

• library - The compiled library to dynamically link

Errors

Returns an error if the library cannot be added to the assembler

pub fn with_statically_linked_library( self, library: &Library, ) -> Result<Self, CodeBuilderError>

Builder-style method to statically link a library and return the modified builder.

This enables method chaining for convenient builder patterns.

Arguments

• library - The compiled library to statically link

Errors

Returns an error if the library cannot be added to the assembler

pub fn with_dynamically_linked_library( self, library: impl AsRef<Library>, ) -> Result<Self, CodeBuilderError>

Builder-style method to dynamically link a library and return the modified builder.

This enables method chaining for convenient builder patterns.

Arguments

• library - The compiled library to dynamically link

Errors

Returns an error if the library cannot be added to the assembler

pub fn with_linked_module( self, module_path: impl AsRef<str>, module_code: impl Parse, ) -> Result<Self, CodeBuilderError>

Builder-style method to link a module and return the modified builder.

This enables method chaining for convenient builder patterns.

Arguments

• module_path - The path identifier for the module (e.g., “my_lib::my_module”)
• module_code - The source code of the module to compile and link

Errors

Returns an error if the module cannot be compiled or added to the assembler

pub fn compile_component_code( self, component_path: impl AsRef<str>, component_code: impl Parse, ) -> Result<AccountComponentCode, CodeBuilderError>

Compiles the provided module path and MASM code into an AccountComponentCode. The resulting code can be used to create account components.

Arguments

• component_path - The path to the account code module (e.g., my_account::my_module)
• component_code - The account component source code

Errors

Returns an error if:

• Compiling the account component code fails

pub fn compile_tx_script( self, tx_script: impl Parse, ) -> Result<TransactionScript, CodeBuilderError>

Compiles the provided MASM code into a TransactionScript.

The parsed script will have access to all modules that have been added to this builder.

Arguments

• tx_script - The transaction script source code

Errors

Returns an error if:

• The transaction script compiling fails

pub fn compile_note_script( self, program: impl Parse, ) -> Result<NoteScript, CodeBuilderError>

Compiles the provided MASM code into a NoteScript.

The parsed script will have access to all modules that have been added to this builder.

Arguments

• program - The note script source code

Errors

Returns an error if:

• The note script compiling fails

pub fn source_manager(&self) -> Arc<dyn SourceManagerSync>

Access the Assembler’s SourceManagerSync.

Trait Implementations

impl Clone for CodeBuilder

fn clone(&self) -> CodeBuilder

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for CodeBuilder

fn default() -> Self

Returns the “default value” for a type.

impl From<CodeBuilder> for Assembler

fn from(builder: CodeBuilder) -> Self

Converts to this type from the input type.