Struct ScriptBuilder 

pub struct ScriptBuilder { /* private fields */ }

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

The ScriptBuilder 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 ScriptBuilder 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 compilation methods consume the ScriptBuilder, so if you need to compile multiple scripts with the same configuration, you should clone the builder first.

Builder Pattern Example

let script = ScriptBuilder::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 compile tx script")?;

Note

The ScriptBuilder 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 ScriptBuilder

pub fn new(in_debug_mode: bool) -> ScriptBuilder

Creates a new ScriptBuilder with the specified debug mode.

Arguments

• in_debug_mode - Whether to enable debug mode in the assembler

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

Creates a new ScriptBuilder with the specified source manager.

The returned builder is instantiated with debug mode enabled.

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 AsRef<str>, ) -> Result<(), ScriptBuilderError>

Compiles and links a module to the script 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<(), ScriptBuilderError>

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<(), ScriptBuilderError>

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<ScriptBuilder, ScriptBuilderError>

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: &Library, ) -> Result<ScriptBuilder, ScriptBuilderError>

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 AsRef<str>, ) -> Result<ScriptBuilder, ScriptBuilderError>

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_tx_script( self, tx_script: impl AsRef<str>, ) -> Result<TransactionScript, ScriptBuilderError>

Compiles a transaction script with the provided program code.

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

Arguments

• program - The transaction script source code

Errors

Returns an error if:

• The transaction script compilation fails

pub fn compile_note_script( self, program: impl AsRef<str>, ) -> Result<NoteScript, ScriptBuilderError>

Compiles a note script with the provided program code.

The compiled 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 compilation fails

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

Access the Assembler’s SourceManagerSync.

Trait Implementations

impl Clone for ScriptBuilder

fn clone(&self) -> ScriptBuilder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for ScriptBuilder

fn default() -> ScriptBuilder

Returns the “default value” for a type.