Running scripts

You can run a script using its JSON-ABI and the path to its binary file. You can run the scripts with arguments. For this, you have to use the abigen! macro seen previously.

    // The abigen is used for the same purpose as with contracts (Rust bindings)
    abigen!(Script(name="MyScript", abi="packages/fuels/tests/scripts/script_with_arguments/out/debug/script_with_arguments-abi.json"));
    let wallet = launch_provider_and_get_wallet().await;
    let bin_path =
    let instance = MyScript::new(wallet, bin_path);

    let bim = Bimbam { val: 90 };
    let bam = SugarySnack {
        twix: 100,
        mars: 1000,
    let result = instance.main(bim, bam).call().await?;
    let expected = Bimbam { val: 2190 };
    assert_eq!(result.value, expected);

Running scripts with transaction parameters

The method for passing transaction parameters is the same as with contracts. As a reminder, the workflow would look like this:

    let parameters = TxParameters {
        gas_price: 1,
        gas_limit: 10000,
    let result = instance.main(a, b).tx_params(parameters).call().await?;


Script calls provide the same logging functions, get_logs() and get_logs_with_type<T>(), as contract calls. As a reminder, the workflow looks like this:

        name = "log_script",
        abi = "packages/fuels/tests/logs/script_logs/out/debug/script_logs-abi.json"

    let wallet = launch_provider_and_get_wallet().await;
    let bin_path = "../fuels/tests/logs/script_logs/out/debug/script_logs.bin";
    let instance = log_script::new(wallet.clone(), bin_path);

    let response = instance.main().call().await?;

    let logs = response.get_logs()?;
    let log_u64 = response.get_logs_with_type::<u64>()?;

Calling contracts from scripts

Scripts use the same interfaces for setting external contracts as contract methods.

Below is an example that uses set_contracts(&[&contract_instance, ...]).

    let response = instance

And this is an example that uses set_contract_ids(&[&contract_id, ...]).

    let response = instance

Configurable constants

Same as contracts, you can define configurable constants in scripts which can be changed during the script execution. Here is an example how the constants are defined.


enum EnumWithGeneric<D> {
    VariantOne: D,
    VariantTwo: (),

struct StructWithGeneric<D> {
    field_1: D,
    field_2: u64,

configurable {
    U8: u8 = 8u8,
    BOOL: bool = true,
    ARRAY: [u32; 3] = [253u32, 254u32, 255u32],
    STR_4: str[4] = "fuel",
    STRUCT: StructWithGeneric<u8> = StructWithGeneric {
        field_1: 8u8,
        field_2: 16,
    ENUM: EnumWithGeneric<bool> = EnumWithGeneric::VariantOne(true),

fn main() -> (u8, bool, [u32; 3], str[4], StructWithGeneric<u8>, EnumWithGeneric<bool>) {

Each of the configurable constants will get a dedicated set method in the SDK. For example, the constant STR_4 will get the set_str_4 method which accepts the same types as defined in sway. Below is an example where we chain several set methods and execute the script with the new constants.

    abigen!(Script(name="MyScript", abi="packages/fuels/tests/scripts/script_configurables/out/debug/script_configurables-abi.json"));

    let wallet = launch_provider_and_get_wallet().await;
    let bin_path = "../fuels/tests/scripts/script_configurables/out/debug/script_configurables.bin";
    let instance = MyScript::new(wallet, bin_path);

    let new_str: SizedAsciiString<4> = "FUEL".try_into()?;
    let new_struct = StructWithGeneric {
        field_1: 16u8,
        field_2: 32,
    let new_enum = EnumWithGeneric::VariantTwo;

    let configurables = MyScriptConfigurables::new()

    let response = instance