@ohos-ports/azle 0.33.0-beta.0

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_insert.rs

@@ -0,0 +1,44 @@
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::{
+    ic::throw_error,
+    stable_b_tree_map::{
+        AzleStableBTreeMapKey, AzleStableBTreeMapValue, with_stable_b_tree_map_mut,
+    },
+};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |memory_id: u8,
+              key_typed_array: TypedArray<u8>,
+              value_typed_array: TypedArray<u8>|
+              -> Result<Option<TypedArray<u8>>> {
+            with_stable_b_tree_map_mut(ctx.clone(), memory_id, |stable_b_tree_map| {
+                let key_slice: &[u8] = key_typed_array.as_ref();
+                let key: Vec<u8> = key_slice.to_vec();
+                let azle_stable_b_tree_map_key = AzleStableBTreeMapKey { bytes: key };
+
+                let inserting_a_new_item =
+                    stable_b_tree_map.contains_key(&azle_stable_b_tree_map_key) == false;
+                let max_u32 = 2u64.pow(32) - 1;
+
+                if inserting_a_new_item && stable_b_tree_map.len() >= max_u32 {
+                    return Err(throw_error(
+                        ctx.clone(),
+                        "StableBTreeMap is currently limited to 2^32 - 1 (4_294_967_295) items or fewer",
+                    ));
+                }
+
+                let value_slice: &[u8] = value_typed_array.as_ref();
+                let value: Vec<u8> = value_slice.to_vec();
+                let azle_stable_b_tree_map_value = AzleStableBTreeMapValue { bytes: value };
+
+                stable_b_tree_map
+                    .insert(azle_stable_b_tree_map_key, azle_stable_b_tree_map_value)
+                    .map(|value| TypedArray::<u8>::new(ctx.clone(), value.bytes))
+                    .transpose()
+            })?
+        },
+    )
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_is_empty.rs

@@ -0,0 +1,11 @@
+use rquickjs::{Ctx, Function, Result};
+
+use crate::stable_b_tree_map::with_stable_b_tree_map;
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move |memory_id: u8| -> Result<bool> {
+        with_stable_b_tree_map(ctx.clone(), memory_id, |stable_b_tree_map| {
+            stable_b_tree_map.is_empty()
+        })
+    })
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_items.rs

@@ -0,0 +1,48 @@
+use std::convert::TryInto;
+
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::{ic::throw_error, stable_b_tree_map::with_stable_b_tree_map};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |memory_id: u8,
+              start_index_option: Option<u32>,
+              length_option: Option<u32>|
+              -> Result<Vec<Vec<TypedArray<u8>>>> {
+            with_stable_b_tree_map(ctx.clone(), memory_id, |stable_b_tree_map| {
+                let skip_amount: usize = if let Some(start_index) = start_index_option {
+                    start_index
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    0
+                };
+
+                let take_amount: usize = if let Some(length) = length_option {
+                    length.try_into().map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    stable_b_tree_map
+                        .len()
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                };
+
+                let items: Vec<Vec<TypedArray<u8>>> = stable_b_tree_map
+                    .iter()
+                    .skip(skip_amount)
+                    .take(take_amount)
+                    .map(|(key, value)| {
+                        Ok(vec![
+                            TypedArray::<u8>::new(ctx.clone(), key.bytes)?,
+                            TypedArray::<u8>::new(ctx.clone(), value.bytes)?,
+                        ])
+                    })
+                    .collect::<Result<Vec<Vec<TypedArray<u8>>>>>()?;
+
+                Ok(items)
+            })?
+        },
+    )
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_keys.rs

@@ -0,0 +1,43 @@
+use std::convert::TryInto;
+
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::{ic::throw_error, stable_b_tree_map::with_stable_b_tree_map};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |memory_id: u8,
+              start_index_option: Option<u32>,
+              length_option: Option<u32>|
+              -> Result<Vec<TypedArray<u8>>> {
+            with_stable_b_tree_map(ctx.clone(), memory_id, |stable_b_tree_map| {
+                let skip_amount: usize = if let Some(start_index) = start_index_option {
+                    start_index
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    0
+                };
+
+                let take_amount: usize = if let Some(length) = length_option {
+                    length.try_into().map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    stable_b_tree_map
+                        .len()
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                };
+
+                let keys: Vec<TypedArray<u8>> = stable_b_tree_map
+                    .iter()
+                    .skip(skip_amount)
+                    .take(take_amount)
+                    .map(|(key, _)| TypedArray::<u8>::new(ctx.clone(), key.bytes))
+                    .collect::<Result<Vec<TypedArray<u8>>>>()?;
+
+                Ok(keys)
+            })?
+        },
+    )
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_len.rs

@@ -0,0 +1,16 @@
+use rquickjs::{Ctx, Function, Result};
+
+use crate::{ic::throw_error, stable_b_tree_map::with_stable_b_tree_map};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move |memory_id: u8| -> Result<u32> {
+        with_stable_b_tree_map(ctx.clone(), memory_id, |stable_b_tree_map| {
+            stable_b_tree_map.len().try_into().map_err(|e| {
+                throw_error(
+                    ctx.clone(),
+                    format!("StableBTreeMap length is currently limited to 2^32 - 1 (4_294_967_295) items or fewer: {e}"),
+                )
+            })
+        })?
+    })
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_remove.rs

@@ -0,0 +1,21 @@
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::stable_b_tree_map::{AzleStableBTreeMapKey, with_stable_b_tree_map_mut};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |memory_id: u8, key_typed_array: TypedArray<u8>| -> Result<Option<TypedArray<u8>>> {
+            with_stable_b_tree_map_mut(ctx.clone(), memory_id, |stable_b_tree_map| {
+                let key_slice: &[u8] = key_typed_array.as_ref();
+                let key: Vec<u8> = key_slice.to_vec();
+                let azle_sable_b_tree_map_key = AzleStableBTreeMapKey { bytes: key };
+
+                stable_b_tree_map
+                    .remove(&azle_sable_b_tree_map_key)
+                    .map(|value| TypedArray::<u8>::new(ctx.clone(), value.bytes))
+                    .transpose()
+            })?
+        },
+    )
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/stable_b_tree_map_values.rs

@@ -0,0 +1,43 @@
+use std::convert::TryInto;
+
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::{ic::throw_error, stable_b_tree_map::with_stable_b_tree_map};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |memory_id: u8,
+              start_index_option: Option<u32>,
+              length_option: Option<u32>|
+              -> Result<Vec<TypedArray<u8>>> {
+            with_stable_b_tree_map(ctx.clone(), memory_id, |stable_b_tree_map| {
+                let skip_amount: usize = if let Some(start_index) = start_index_option {
+                    start_index
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    0
+                };
+
+                let take_amount: usize = if let Some(length) = length_option {
+                    length.try_into().map_err(|e| throw_error(ctx.clone(), e))?
+                } else {
+                    stable_b_tree_map
+                        .len()
+                        .try_into()
+                        .map_err(|e| throw_error(ctx.clone(), e))?
+                };
+
+                let values: Vec<TypedArray<u8>> = stable_b_tree_map
+                    .iter()
+                    .skip(skip_amount)
+                    .take(take_amount)
+                    .map(|(_, value)| TypedArray::<u8>::new(ctx.clone(), value.bytes))
+                    .collect::<Result<Vec<TypedArray<u8>>>>()?;
+
+                Ok(values)
+            })?
+        },
+    )
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/time.rs

@@ -0,0 +1,8 @@
+use ic_cdk::api::time;
+use rquickjs::{BigInt, Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move || -> Result<BigInt> {
+        BigInt::from_u64(ctx.clone(), time())
+    })
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/trap.rs

@@ -0,0 +1,22 @@
+// TODO readdress the workarounds below once this issue is resolved: https://github.com/DelSkayn/rquickjs/issues/413
+
+use ic_cdk::api::trap;
+use rquickjs::{Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, |message: String| -> () { cast_trap(message) })
+}
+
+/// This function is needed to handle the never type (!) return from trap() in a Function::new closure.
+/// The trap() function has a never return type (!), but we need to return () to satisfy the Function::new
+/// closure requirements. Without explicitly returning (), we would get compiler warnings about
+/// depending on never type fallback being (), which is being phased out in Rust.
+///
+/// This avoids warnings like:
+/// - "this function depends on never type fallback being ()"
+/// - "in edition 2024, the requirement !: rquickjs::IntoJs<'_> will fail"
+pub fn cast_trap(message: String) -> () {
+    trap(&message);
+    #[allow(unreachable_code)]
+    ()
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/init_and_post_upgrade.rs

@@ -0,0 +1,98 @@
+use std::{error::Error, str, time::Duration};
+
+use candid::Principal;
+use ic_cdk::{call::Call, futures::spawn, trap};
+use ic_cdk_timers::set_timer;
+use ic_stable_structures::memory_manager::MemoryId;
+use ic_wasi_polyfill::init_with_memory;
+
+use crate::{
+    MEMORY_MANAGER_REF_CELL,
+    execute_method_js::execute_method_js,
+    ic::rand_seed,
+    initialize_context::{WasmEnvironment, initialize_context},
+    wasm_binary_manipulation::{get_js_code, get_wasm_data},
+};
+
+#[inline(never)]
+#[unsafe(no_mangle)]
+pub extern "C" fn init(function_index: i32) {
+    // Without something like this to make the function bodies different,
+    // the init and post_upgrade functions
+    // seem to be optimized into the same function in the Wasm binary
+    // This causes problems during Wasm binary manipulation
+    let _ = format!("prevent init and post_upgrade optimization");
+
+    if let Err(e) = initialize(true, function_index) {
+        trap(&format!("Azle InitError: {}", e));
+    }
+}
+
+#[inline(never)]
+#[unsafe(no_mangle)]
+pub extern "C" fn post_upgrade(function_index: i32) {
+    if let Err(e) = initialize(false, function_index) {
+        trap(&format!("Azle PostUpgradeError: {}", e));
+    }
+}
+
+fn initialize(init: bool, function_index: i32) -> Result<(), Box<dyn Error>> {
+    let js = get_js_code()?;
+    let wasm_data = get_wasm_data()?;
+
+    let env_vars: Vec<(&str, &str)> = wasm_data
+        .env_vars
+        .iter()
+        .map(|(key, value)| (key.as_str(), value.as_str()))
+        .collect();
+
+    let polyfill_memory =
+        MEMORY_MANAGER_REF_CELL.with(|manager| manager.borrow().get(MemoryId::new(254)));
+
+    init_with_memory(&[], &env_vars, polyfill_memory);
+
+    initialize_context(
+        js,
+        &wasm_data.main_js_path,
+        WasmEnvironment::IcpReplica,
+        Some(init),
+    )?;
+
+    execute_developer_init_or_post_upgrade(function_index);
+
+    seed_from_raw_rand();
+
+    Ok(())
+}
+
+fn execute_developer_init_or_post_upgrade(function_index: i32) {
+    if function_index != -1 {
+        execute_method_js(function_index);
+    }
+}
+
+fn seed_from_raw_rand() {
+    set_timer(Duration::new(0, 0), || {
+        spawn(async {
+            let result: Result<(), Box<dyn Error>> = async {
+                let randomness: Vec<u8> =
+                    Call::unbounded_wait(Principal::management_canister(), "raw_rand")
+                        .await?
+                        .candid()?;
+
+                rand_seed(
+                    randomness
+                        .try_into()
+                        .map_err(|_| "seed must be exactly 32 bytes in length")?,
+                );
+
+                Ok(())
+            }
+            .await;
+
+            if let Err(e) = result {
+                trap(&format!("Azle SeedFromRawRandError: {}", e));
+            }
+        });
+    });
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/initialize_context.rs

@@ -0,0 +1,102 @@
+use std::{env::vars, error::Error};
+
+use rquickjs::{Array, Context, Module, Object, Runtime, Undefined};
+
+use crate::{
+    CONTEXT_REF_CELL,
+    ic::{drain_microtasks, register},
+    rquickjs_utils::{handle_promise_error, with_ctx},
+};
+
+pub enum WasmEnvironment {
+    IcpReplica,
+    Nodejs,
+}
+
+/// Initializes the rquickjs context with the given JavaScript code.
+///
+/// ## Remarks
+///
+/// This function creates an rquickjs Runtime and Context, stores the Context globally,
+/// then prepares the context and executes the JavaScript code. This functionality is shared
+/// across canister_init, canister_post_upgrade, and Candid/MethodMeta generation.
+pub fn initialize_context(
+    js: Vec<u8>,
+    main_js_path: &str,
+    wasm_environment: WasmEnvironment,
+    init: Option<bool>,
+) -> Result<(), Box<dyn Error>> {
+    let runtime = Runtime::new()?;
+    let context = Context::full(&runtime)?;
+
+    CONTEXT_REF_CELL.with(|context_ref_cell| {
+        *context_ref_cell.borrow_mut() = Some(context);
+    });
+
+    with_ctx(|ctx| {
+        let globals = ctx.globals();
+
+        globals.set("_azleActions", Array::new(ctx.clone()))?;
+
+        globals.set("_azleCanisterMethodNames", Object::new(ctx.clone())?)?;
+
+        globals.set("_azleExperimental", false)?;
+
+        globals.set("_azleCanisterClassMeta", Undefined)?;
+
+        globals.set("_azleIcExperimental", Undefined)?;
+
+        globals.set(
+            "_azleIcpReplicaWasmEnvironment",
+            matches!(wasm_environment, WasmEnvironment::IcpReplica),
+        )?;
+
+        // initializes globalThis._azleIc
+        register(ctx.clone())?;
+
+        globals.set("_azleInitCalled", init == Some(true))?;
+
+        globals.set(
+            "_azleNodejsWasmEnvironment",
+            matches!(wasm_environment, WasmEnvironment::Nodejs),
+        )?;
+
+        globals.set("_azlePostUpgradeCalled", init == Some(false))?;
+
+        globals.set("_azleRejectCallbacks", Object::new(ctx.clone())?)?;
+
+        globals.set("_azleResolveCallbacks", Object::new(ctx.clone())?)?;
+
+        globals.set("_azleTimerCallbacks", Object::new(ctx.clone())?)?;
+
+        globals.set("exports", Object::new(ctx.clone())?)?;
+
+        let env = Object::new(ctx.clone())?;
+
+        for (key, value) in vars() {
+            env.set(key, value)?;
+        }
+
+        let process = Object::new(ctx.clone())?;
+
+        process.set("env", env)?;
+
+        globals.set("process", process)?;
+
+        // JavaScript code execution: macrotask
+        let promise = Module::evaluate(ctx.clone(), main_js_path, js)?;
+
+        // We should handle the promise error before drain_microtasks
+        // as all JavaScript microtasks queued from the JavaScript macrotask code execution above
+        // will be discarded if there is a trap
+        handle_promise_error(&ctx, &promise)?;
+
+        // We must drain all microtasks that could have been queued during the JavaScript macrotask code execution above
+        drain_microtasks(&ctx);
+
+        Ok(())
+    })
+
+    // Note that we don't call drain_inter_canister_call_futures here because initialize_context is only used
+    // with init, post_upgrade, and Candid/MethodMeta generation. None of those allow for inter-canister calls.
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/internal_canister_methods.rs

@@ -0,0 +1,122 @@
+use std::error::Error;
+
+use ic_cdk::{query, trap, update};
+use rquickjs::{Array, Object, Value};
+
+use crate::{
+    CONTEXT_REF_CELL, INTER_CANISTER_CALL_FUTURES, PEAK_ALLOC,
+    benchmarking::{BENCHMARKS_REF_CELL, BenchmarkEntry},
+    guards::guard_against_non_controllers,
+    rquickjs_utils::with_ctx,
+};
+
+/// Used in conjunction with the JavaScript `chunk` function to increase the effective update call instruction limit.
+#[update]
+fn _azle_chunk() {}
+
+/// Returns the stored benchmarks if the benchmarking functionality is enabled.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_get_benchmarks() -> Vec<BenchmarkEntry> {
+    BENCHMARKS_REF_CELL.with(|benchmarks_ref_cell| benchmarks_ref_cell.borrow().clone())
+}
+
+/// Returns the current length of globalThis._azleRejectCallbacks to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_reject_callbacks_len() -> u32 {
+    let result = with_ctx(|ctx| -> Result<u32, Box<dyn Error>> {
+        let globals = ctx.globals();
+
+        let _azle_reject_callbacks: Object = globals.get("_azleRejectCallbacks")?;
+
+        Ok(_azle_reject_callbacks.keys::<Value>().len() as u32)
+    });
+
+    match result {
+        Ok(len) => len,
+        Err(e) => trap(&format!("Azle RejectCallbacksLenError: {}", e)),
+    }
+}
+
+/// Returns the current length of globalThis._azleResolveCallbacks to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_resolve_callbacks_len() -> u32 {
+    let result = with_ctx(|ctx| -> Result<u32, Box<dyn Error>> {
+        let globals = ctx.globals();
+
+        let _azle_resolve_callbacks: Object = globals.get("_azleResolveCallbacks")?;
+
+        Ok(_azle_resolve_callbacks.keys::<Value>().len() as u32)
+    });
+
+    match result {
+        Ok(len) => len,
+        Err(e) => trap(&format!("Azle ResolveCallbacksLenError: {}", e)),
+    }
+}
+
+/// Returns the current length of globalThis._azleTimerCallbacks to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_timer_callbacks_len() -> u32 {
+    let result = with_ctx(|ctx| -> Result<u32, Box<dyn Error>> {
+        let globals = ctx.globals();
+
+        let _azle_timer_callbacks: Object = globals.get("_azleTimerCallbacks")?;
+
+        Ok(_azle_timer_callbacks.keys::<Value>().len() as u32)
+    });
+
+    match result {
+        Ok(len) => len,
+        Err(e) => trap(&format!("Azle TimerCallbacksLenError: {}", e)),
+    }
+}
+
+/// Returns the current length of globalThis._azleActions to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_actions_len() -> u32 {
+    let result = with_ctx(|ctx| -> Result<u32, Box<dyn Error>> {
+        let globals = ctx.globals();
+
+        let _azle_actions: Array = globals.get("_azleActions")?;
+
+        Ok(_azle_actions.len() as u32)
+    });
+
+    match result {
+        Ok(len) => len,
+        Err(e) => trap(&format!("Azle ActionsLenError: {}", e)),
+    }
+}
+
+/// Returns the current length of the INTER_CANISTER_CALL_FUTURES Vec to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_inter_canister_call_futures_len() -> u32 {
+    INTER_CANISTER_CALL_FUTURES.with(|inter_canister_call_futures_ref_cell| {
+        inter_canister_call_futures_ref_cell.borrow().len() as u32
+    })
+}
+
+/// Returns the current length of the QuickJS internal job queue to aid in testing for event loop problems, memory leaks, and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_is_job_queue_empty() -> bool {
+    let result = CONTEXT_REF_CELL.with(|context_ref_cell| -> Result<bool, Box<dyn Error>> {
+        let context = context_ref_cell
+            .borrow()
+            .clone()
+            .ok_or("QuickJS context not initialized")?;
+        let runtime = context.runtime();
+
+        Ok(!runtime.is_job_pending())
+    });
+
+    match result {
+        Ok(is_empty) => is_empty,
+        Err(e) => trap(&format!("Azle IsJobQueueEmptyError: {}", e)),
+    }
+}
+
+/// Returns the current size of the heap in bytes to aid in testing for memory leaks and other global state issues.
+#[query(guard = "guard_against_non_controllers")]
+fn _azle_heap_allocation() -> u32 {
+    PEAK_ALLOC.current_usage() as u32
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/lib.rs

@@ -0,0 +1,39 @@
+use std::cell::RefCell;
+use std::future::Future;
+use std::pin::Pin;
+
+use ic_stable_structures::{
+    DefaultMemoryImpl,
+    memory_manager::{MemoryManager, VirtualMemory},
+};
+use peak_alloc::PeakAlloc;
+use rand::{SeedableRng, rngs::StdRng};
+use rquickjs::Context;
+
+mod benchmarking;
+mod candid_and_method_meta;
+mod execute_method_js;
+mod guards;
+mod ic;
+mod init_and_post_upgrade;
+mod initialize_context;
+mod internal_canister_methods;
+mod rquickjs_utils;
+mod stable_b_tree_map;
+mod state;
+mod wasm_binary_manipulation;
+
+#[global_allocator]
+static PEAK_ALLOC: PeakAlloc = PeakAlloc;
+
+#[allow(unused)]
+type Memory = VirtualMemory<DefaultMemoryImpl>;
+
+type InterCanisterCallFuture = Pin<Box<dyn Future<Output = ()> + 'static>>;
+
+thread_local! {
+    static CONTEXT_REF_CELL: RefCell<Option<Context>> = RefCell::new(None);
+    static CSPRNG: RefCell<StdRng> = RefCell::new(StdRng::from_seed([0;32]));
+    static INTER_CANISTER_CALL_FUTURES: RefCell<Vec<InterCanisterCallFuture>> = RefCell::new(Vec::new());
+    static MEMORY_MANAGER_REF_CELL: RefCell<MemoryManager<DefaultMemoryImpl>> = RefCell::new(MemoryManager::init(DefaultMemoryImpl::default()));
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/rquickjs_utils/call_with_error_handling.rs

@@ -0,0 +1,26 @@
+use std::error::Error;
+
+use rquickjs::{Ctx, Function, Promise, Value, function::IntoArgs};
+
+use crate::rquickjs_utils::{handle_promise_error, trap_on_last_exception};
+
+pub fn call_with_error_handling<'a>(
+    ctx: &Ctx<'a>,
+    function: &Function<'a>,
+    args: impl IntoArgs<'a>,
+) -> Result<Value<'a>, Box<dyn Error>> {
+    let result: Value = match function.call(args) {
+        Ok(value) => value,
+        Err(_) => trap_on_last_exception(ctx)?,
+    };
+
+    if result.is_promise() {
+        let promise: Promise = result
+            .clone()
+            .into_promise()
+            .ok_or("Failed to convert function call return JS value to promise")?;
+        handle_promise_error(ctx, &promise)?;
+    }
+
+    Ok(result)
+}

package/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/rquickjs_utils/error.rs

@@ -0,0 +1,27 @@
+use std::error::Error;
+
+use ic_cdk::trap;
+use rquickjs::{Ctx, Exception, Promise, Value, promise::PromiseState};
+
+pub fn handle_promise_error(ctx: &Ctx, promise: &Promise) -> Result<(), Box<dyn Error>> {
+    match promise.state() {
+        PromiseState::Rejected => {
+            promise.result::<Value>();
+            trap_on_last_exception(ctx)?;
+        }
+        _ => {}
+    };
+
+    Ok(())
+}
+
+pub fn trap_on_last_exception<T>(ctx: &Ctx) -> Result<T, Box<dyn Error>> {
+    let exception: Exception = ctx
+        .clone()
+        .catch()
+        .as_exception()
+        .ok_or("No exception found")?
+        .clone();
+
+    trap(&exception.to_string());
+}