@ohos-ports/azle 0.33.0-beta.0

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

@@ -0,0 +1,49 @@
+use std::{error::Error, ffi::CString, os::raw::c_char};
+
+use ic_cdk::trap;
+use rquickjs::Function;
+
+use crate::{
+    initialize_context::{WasmEnvironment, initialize_context},
+    rquickjs_utils::{call_with_error_handling, with_ctx},
+    wasm_binary_manipulation::{get_js_code, get_wasm_data},
+};
+
+type CCharPtr = *mut c_char;
+
+#[unsafe(no_mangle)]
+pub fn get_candid_and_method_meta_pointer() -> CCharPtr {
+    match initialize_and_get_candid_and_method_meta() {
+        Ok(c_char_ptr) => c_char_ptr,
+        Err(error) => {
+            trap(&format!("Candid and MethodMeta generation failed: {error}"));
+        }
+    }
+}
+
+fn initialize_and_get_candid_and_method_meta() -> Result<CCharPtr, Box<dyn Error>> {
+    let js = get_js_code()?;
+    let wasm_data = get_wasm_data()?;
+
+    initialize_context(js, &wasm_data.main_js_path, WasmEnvironment::Nodejs, None)?;
+
+    with_ctx(|ctx| {
+        let get_candid_and_method_meta: Function = ctx
+            .globals()
+            .get("_azleGetCandidAndMethodMeta")
+            .map_err(|e| format!("Failed to get globalThis._azleGetCandidAndMethodMeta: {e}"))?;
+
+        let candid_and_method_meta_js_value =
+            call_with_error_handling(&ctx, &get_candid_and_method_meta, ())?;
+
+        let candid_and_method_meta: String = candid_and_method_meta_js_value
+            .as_string()
+            .ok_or("Failed to convert candidAndMethodMeta JS value to string")?
+            .to_string()?;
+
+        let c_string = CString::new(candid_and_method_meta)?;
+        let c_char_ptr = c_string.into_raw();
+
+        Ok(c_char_ptr)
+    })
+}

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

@@ -0,0 +1,65 @@
+use std::{env::var, error::Error};
+
+use ic_cdk::{api::performance_counter, futures::in_executor_context, trap};
+use rquickjs::{Function, Object};
+
+use crate::{
+    benchmarking::record_benchmark,
+    ic::{drain_inter_canister_call_futures, drain_microtasks},
+    rquickjs_utils::{call_with_error_handling, with_ctx},
+};
+
+#[unsafe(no_mangle)]
+#[allow(unused)]
+pub extern "C" fn execute_method_js(function_index: i32) {
+    let function_name = function_index.to_string();
+
+    let result = execute_method_js_with_result(function_name);
+
+    if let Err(e) = result {
+        trap(&format!("Azle CanisterMethodError: {}", e));
+    }
+}
+
+fn execute_method_js_with_result(function_name: String) -> Result<(), Box<dyn Error>> {
+    with_ctx(|ctx| {
+        let canister_class_meta: Object = ctx
+            .clone()
+            .globals()
+            .get("_azleCanisterClassMeta")
+            .map_err(|e| format!("Failed to get globalThis._azleCanisterClassMeta: {e}"))?;
+
+        let callbacks: Object = canister_class_meta.get("callbacks").map_err(|e| {
+            format!("Failed to get globalThis._azleCanisterClassMeta.callbacks: {e}")
+        })?;
+
+        let method_callback: Function = callbacks.get(&function_name).map_err(|e| {
+            format!(
+                "Failed to get globalThis._azleCanisterClassMeta.callbacks[{function_name}]: {e}"
+            )
+        })?;
+
+        // JavaScript code execution: macrotask
+        call_with_error_handling(&ctx, &method_callback, ())?;
+
+        // We must drain all microtasks that could have been queued during the JavaScript macrotask code execution above
+        drain_microtasks(&ctx);
+
+        Ok(())
+    })?;
+
+    // We must drain all inter-canister call futures that could have been queued during the JavaScript code execution above
+    // This MUST be called outside of the with_ctx closure or it will trap
+    in_executor_context(|| {
+        drain_inter_canister_call_futures();
+    });
+
+    if let Ok(azle_record_benchmarks) = var("AZLE_RECORD_BENCHMARKS") {
+        if azle_record_benchmarks == "true" {
+            let instructions = performance_counter(1);
+            record_benchmark(&function_name, instructions)?;
+        }
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,11 @@
+use ic_cdk::api::{is_controller, msg_caller};
+
+#[allow(unused)]
+pub fn guard_against_non_controllers() -> Result<(), String> {
+    if is_controller(&msg_caller()) {
+        return Ok(());
+    }
+    return Err(
+        "Not Authorized: only controllers of this canister may call this method".to_string(),
+    );
+}

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

@@ -0,0 +1,6 @@
+use ic_cdk::api::accept_message;
+use rquickjs::{Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, || -> () { accept_message() })
+}

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

@@ -0,0 +1,362 @@
+use std::error::Error;
+
+use candid::Principal;
+use ic_cdk::{
+    call::{Call, CallFailed, Response},
+    futures::{is_recovering_from_trap, spawn},
+    trap,
+};
+use rquickjs::{
+    BigInt, Ctx, Exception, Function, IntoJs, Object, Result as QuickJsResult, TypedArray, Value,
+};
+
+use crate::{
+    INTER_CANISTER_CALL_FUTURES, InterCanisterCallFuture,
+    ic::{drain_microtasks, throw_error},
+    rquickjs_utils::{call_with_error_handling, with_ctx},
+    state::dispatch_action,
+};
+
+pub enum CallErrorType {
+    CallFailed(CallFailed),
+    CleanupCallback,
+}
+
+#[derive(Clone, Copy)]
+enum SettleType {
+    Resolve,
+    Reject,
+}
+
+pub fn get_function(ctx: Ctx) -> QuickJsResult<Function> {
+    Function::new(
+        ctx.clone(),
+        move |global_resolve_id: String,
+              global_reject_id: String,
+              canister_id_bytes: TypedArray<u8>,
+              method: String,
+              args_raw: TypedArray<u8>,
+              cycles_string: String|
+              -> QuickJsResult<()> {
+            let canister_id = Principal::from_slice(canister_id_bytes.as_ref());
+            let args_raw = args_raw
+                .as_bytes()
+                .ok_or(throw_error(
+                    ctx.clone(),
+                    "args_raw could not be converted into bytes",
+                ))?
+                .to_vec();
+            let payment: u128 = cycles_string
+                .parse()
+                .map_err(|e| throw_error(ctx.clone(), e))?;
+
+            let inter_canister_call_future = Box::pin(async move {
+                // My understanding of how this works:
+                // scopeguard will execute its closure at the end of the scope.
+                // After a successful or unsuccessful inter-canister call (await point)
+                // the closure will run, cleaning up the global promise callbacks and settling the inter-canister promise.
+                // Even during a trap, the IC will ensure that the closure runs in its own call (the cleanup callback)
+                // thus allowing us to recover from a trap and persist that state
+                let _cleanup_scopeguard = scopeguard::guard((), |_| {
+                    let result = with_ctx(|ctx| {
+                        // JavaScript code execution: macrotask (when running as an ICP cleanup callback)
+                        // The ICP cleanup callback is executed when an inter-canister call reply or reject callback traps
+                        // If the reply or reject callback does not trap, this will run in the same call
+                        // as the reply or reject callback, and thus won't be a macrotask, but will still
+                        // be a JavaScript execution. If the inter-canister call returns synchronously because
+                        // of a synchronous error, this will run in the same ICP call as the original
+                        // execution that called into call_raw (call in JavaScript), and thus won't be a JavaScript macrotask
+                        // but will still be a JavaScript execution
+                        cleanup(
+                            ctx.clone(),
+                            &global_resolve_id,
+                            &global_reject_id,
+                            is_recovering_from_trap(),
+                        )?;
+
+                        // We must drain all microtasks that could have been queued during previous JavaScript executions.
+                        // Those executions include the settle_promise JavaScript execution as a macrotask or regular execution,
+                        // the cleanup call above as a regular JavaScript execution, or the cleanup call above as a macrotask execution
+                        drain_microtasks(&ctx);
+
+                        Ok(())
+                    });
+
+                    if let Err(e) = result {
+                        trap(&format!("Azle CallRawCleanupError: {e}"));
+                    }
+
+                    // We must drain all inter-canister call futures that could have been queued during previous JavaScript executions.
+                    // Those executions include the settle_promise JavaScript execution as a macrotask or regular execution,
+                    // the cleanup call above as a regular JavaScript execution, or the cleanup call above as a macrotask execution.
+                    // This MUST be called outside of the with_ctx closure or it will trap
+                    drain_inter_canister_call_futures();
+                });
+
+                let call_result = Call::unbounded_wait(canister_id, &method)
+                    .with_raw_args(&args_raw)
+                    .with_cycles(payment)
+                    .await;
+
+                let result = with_ctx(|ctx| {
+                    // JavaScript code execution: macrotask (when call_raw128.await does not return synchronously)
+                    settle_promise(
+                        ctx.clone(),
+                        call_result,
+                        &global_resolve_id,
+                        &global_reject_id,
+                    )?;
+
+                    Ok(())
+                });
+
+                if let Err(e) = result {
+                    trap(&format!("Azle CallRawError: {e}"));
+                }
+            });
+
+            INTER_CANISTER_CALL_FUTURES.with(|inter_canister_call_futures_ref_cell| {
+                inter_canister_call_futures_ref_cell
+                    .borrow_mut()
+                    .push(inter_canister_call_future)
+            });
+
+            Ok(())
+        },
+    )
+}
+
+fn cleanup(
+    ctx: Ctx,
+    global_resolve_id: &str,
+    global_reject_id: &str,
+    inside_cleanup_callback: bool,
+) -> Result<(), Box<dyn Error>> {
+    if inside_cleanup_callback {
+        reject_promise_with_cleanup_callback_error(ctx.clone(), global_reject_id)?;
+    }
+
+    dispatch_action(
+        ctx.clone(),
+        "DELETE_AZLE_RESOLVE_CALLBACK",
+        global_resolve_id.into_js(&ctx)?,
+        "azle/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/call_raw.rs",
+        "cleanup",
+    )?;
+
+    dispatch_action(
+        ctx.clone(),
+        "DELETE_AZLE_REJECT_CALLBACK",
+        global_reject_id.into_js(&ctx)?,
+        "azle/src/stable/build/commands/build/wasm_binary/rust/stable_canister_template/src/ic/call_raw.rs",
+        "cleanup",
+    )?;
+
+    Ok(())
+}
+
+/// Constructs the error object that will be used to reject the promise in the cleanup callback.
+///
+/// ## Remarks
+///
+/// If the reply or reject callback of an inter-canister call traps, then the IC will
+/// execute something called the cleanup callback, which is its own call execution.
+/// The purpose is to be able to clean up state from before the call that would have
+/// been cleaned up in the reply or reject callback.
+///
+/// In the cleanup callback, we settle the promise with this special error object.
+/// The developer can detect this and clean up their own state if they'd like,
+/// though they must not trap during the execution of the cleanup callback.
+fn reject_promise_with_cleanup_callback_error(
+    ctx: Ctx,
+    global_reject_id: &str,
+) -> Result<(), Box<dyn Error>> {
+    let reject_callback = get_settle_callback(ctx.clone(), SettleType::Reject, global_reject_id)?;
+
+    let call_error = create_call_error(ctx.clone(), CallErrorType::CleanupCallback)?;
+
+    call_with_error_handling(&ctx, &reject_callback, (call_error,))?;
+
+    Ok(())
+}
+
+fn get_settle_callback<'a>(
+    ctx: Ctx<'a>,
+    settle_type: SettleType,
+    settle_global_id: &str,
+) -> Result<Function<'a>, Box<dyn Error>> {
+    let settle_global_object = get_settle_global_object(ctx.clone(), settle_type)?;
+    Ok(settle_global_object.get(settle_global_id)?)
+}
+
+fn get_settle_global_object(ctx: Ctx, settle_type: SettleType) -> Result<Object, Box<dyn Error>> {
+    let globals = ctx.globals();
+
+    if matches!(settle_type, SettleType::Resolve) {
+        Ok(globals.get("_azleResolveCallbacks")?)
+    } else {
+        Ok(globals.get("_azleRejectCallbacks")?)
+    }
+}
+
+/// Creates the JavaScript error object that will be used to reject the inter-canister call promise.
+///
+/// ## Remarks
+///
+/// This function will create the JavaScript error object for all inter-canister call error cases, including oneway calls and cleanup callbacks.
+/// Those cases are:
+/// - InsufficientLiquidCycleBalance
+/// - CallPerformFailed
+/// - CallRejected
+/// - CleanupCallback
+pub fn create_call_error<'a>(
+    ctx: Ctx<'a>,
+    call_error_type: CallErrorType,
+) -> Result<Exception<'a>, Box<dyn Error>> {
+    let call_error = match call_error_type {
+        CallErrorType::CallFailed(call_failed) => match &call_failed {
+            CallFailed::InsufficientLiquidCycleBalance(insufficient_liquid_cycle_balance) => {
+                let exception = create_call_error_exception(
+                    ctx.clone(),
+                    "InsufficientLiquidCycleBalance",
+                    &call_failed.to_string(),
+                )?;
+
+                exception.set(
+                    "available",
+                    ctx.eval::<BigInt, &str>(&format!(
+                        "{}n",
+                        insufficient_liquid_cycle_balance.available
+                    ))?,
+                )?;
+                exception.set(
+                    "required",
+                    ctx.eval::<BigInt, &str>(&format!(
+                        "{}n",
+                        insufficient_liquid_cycle_balance.required
+                    ))?,
+                )?;
+
+                exception
+            }
+            CallFailed::CallPerformFailed(_) => create_call_error_exception(
+                ctx.clone(),
+                "CallPerformFailed",
+                &call_failed.to_string(),
+            )?,
+            CallFailed::CallRejected(call_rejected) => {
+                let exception = create_call_error_exception(
+                    ctx.clone(),
+                    "CallRejected",
+                    &call_failed.to_string(),
+                )?;
+
+                exception.set("rejectCode", call_rejected.reject_code()? as u32)?;
+                exception.set("rejectMessage", call_rejected.reject_message())?;
+
+                exception
+            }
+        },
+        CallErrorType::CleanupCallback => {
+            let exception = create_call_error_exception(
+                ctx.clone(),
+                "CleanupCallback",
+                "executing within cleanup callback",
+            )?;
+
+            exception.set("rejectCode", 10_001)?;
+            exception.set("rejectMessage", "executing within cleanup callback")?;
+
+            exception
+        }
+    };
+
+    Ok(call_error)
+}
+
+fn create_call_error_exception<'a>(
+    ctx: Ctx<'a>,
+    call_error_type: &str,
+    message: &str,
+) -> Result<Exception<'a>, Box<dyn Error>> {
+    let exception = Exception::from_message(ctx.clone(), message)?;
+
+    exception.set("type", call_error_type)?;
+
+    Ok(exception)
+}
+
+/// Drains and spawns any queued inter-canister call futures.
+///
+/// ## Remarks
+///
+/// Every inter-canister call issued from the JavaScript environment using the `call` API
+/// creates an `InterCanisterCallFuture` and pushes it into the
+/// thread-local `INTER_CANISTER_CALL_FUTURES`.  
+/// When you `.await` such a call, the await can resolve in **two** ways:
+///
+/// 1. **Asynchronously** — the normal case, where the reply arrives later in a
+///    fresh replicated call context (the `reply` or `reject` callback).
+/// 2. **Synchronously** — certain errors (e.g. transient network failures) are
+///    raised immediately, so the `await` resumes *inside* the original
+///    `with_ctx` closure.
+///
+/// In the synchronous path the continuation is already executing within an
+/// outer `with_ctx`; calling `with_ctx` again would panic as `already borrowed`.  
+/// To avoid nested-context errors, each future is queued and executed **after**
+/// a top-level ICP call's `with_ctx` returns.
+///
+pub fn drain_inter_canister_call_futures() {
+    let inter_canister_call_futures: Vec<InterCanisterCallFuture> = INTER_CANISTER_CALL_FUTURES
+        .with(|inter_canister_call_futures_ref_cell| {
+            inter_canister_call_futures_ref_cell
+                .borrow_mut()
+                .drain(..)
+                .collect()
+        });
+
+    for inter_canister_call_future in inter_canister_call_futures {
+        spawn(inter_canister_call_future);
+    }
+}
+
+fn settle_promise<'a>(
+    ctx: Ctx<'a>,
+    call_result: Result<Response, CallFailed>,
+    global_resolve_id: &str,
+    global_reject_id: &str,
+) -> Result<(), Box<dyn Error>> {
+    let (settle_type, settle_js_value) = prepare_settle_js_value(ctx.clone(), call_result)?;
+    let settle_callback = get_settle_callback(
+        ctx.clone(),
+        settle_type,
+        if matches!(settle_type, SettleType::Resolve) {
+            global_resolve_id
+        } else {
+            global_reject_id
+        },
+    )?;
+
+    call_with_error_handling(&ctx, &settle_callback, (settle_js_value,))?;
+
+    Ok(())
+}
+
+fn prepare_settle_js_value<'a>(
+    ctx: Ctx<'a>,
+    call_result: Result<Response, CallFailed>,
+) -> Result<(SettleType, Value<'a>), Box<dyn Error>> {
+    match call_result {
+        Ok(response) => {
+            let candid_bytes_js_value =
+                TypedArray::<u8>::new(ctx.clone(), response.into_bytes()).into_js(&ctx)?;
+
+            Ok((SettleType::Resolve, candid_bytes_js_value))
+        }
+        Err(call_failed) => Ok((
+            SettleType::Reject,
+            create_call_error(ctx.clone(), CallErrorType::CallFailed(call_failed))?
+                .into_js(&ctx)?,
+        )),
+    }
+}

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

@@ -0,0 +1,18 @@
+use candid::IDLArgs;
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::ic::throw_error;
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |candid_encoded: TypedArray<u8>| -> Result<String> {
+            let candid_bytes = candid_encoded.as_ref();
+            let candid_args: IDLArgs =
+                IDLArgs::from_bytes(candid_bytes).map_err(|e| throw_error(ctx.clone(), e))?;
+            let candid_string = candid_args.to_string();
+
+            Ok(candid_string)
+        },
+    )
+}

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

@@ -0,0 +1,19 @@
+use candid_parser::parse_idl_args;
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+use crate::ic::throw_error;
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |candid_string: String| -> Result<TypedArray<u8>> {
+            let candid_args =
+                parse_idl_args(&candid_string).map_err(|e| throw_error(ctx.clone(), e))?;
+            let candid_encoded = candid_args
+                .to_bytes()
+                .map_err(|e| throw_error(ctx.clone(), e))?;
+
+            TypedArray::<u8>::new(ctx.clone(), candid_encoded)
+        },
+    )
+}

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

@@ -0,0 +1,8 @@
+use ic_cdk::api::canister_cycle_balance;
+use rquickjs::{BigInt, Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move || -> Result<BigInt> {
+        ctx.eval::<BigInt, &str>(&format!("{}n", canister_cycle_balance()))
+    })
+}

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

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

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

@@ -0,0 +1,8 @@
+use ic_cdk::api::canister_version;
+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(), canister_version())
+    })
+}

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

@@ -0,0 +1,8 @@
+use ic_cdk::api::certified_data_set;
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, |bytes: TypedArray<u8>| -> () {
+        certified_data_set::<&[u8]>(bytes.as_ref())
+    })
+}

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

@@ -0,0 +1,15 @@
+use ic_cdk_timers::{clear_timer, TimerId};
+use rquickjs::{Ctx, Function, Result};
+use slotmap::KeyData;
+
+use crate::ic::throw_error;
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move |timer_id: String| -> Result<()> {
+        clear_timer(TimerId::from(KeyData::from_ffi(
+            timer_id.parse().map_err(|e| throw_error(ctx.clone(), e))?,
+        )));
+
+        Ok(())
+    })
+}

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

@@ -0,0 +1,17 @@
+use ic_cdk::api::cycles_burn;
+use rquickjs::{BigInt, Ctx, Function, Result};
+
+use crate::ic::throw_error;
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(
+        ctx.clone(),
+        move |amount_string: String| -> Result<BigInt> {
+            let amount: u128 = amount_string
+                .parse()
+                .map_err(|e| throw_error(ctx.clone(), e))?;
+
+            ctx.eval::<BigInt, &str>(&format!("{}n", cycles_burn(amount)))
+        },
+    )
+}

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

@@ -0,0 +1,13 @@
+use ic_cdk::api::data_certificate;
+use rquickjs::{Ctx, Function, IntoJs, Result, TypedArray, Undefined, Value};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move || -> Result<Value> {
+        match data_certificate() {
+            Some(data_certificate_vec_u8) => {
+                TypedArray::<u8>::new(ctx.clone(), data_certificate_vec_u8)?.into_js(&ctx)
+            }
+            None => Undefined.into_js(&ctx),
+        }
+    })
+}

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

@@ -0,0 +1,8 @@
+use ic_cdk::api::debug_print;
+use rquickjs::{Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, |message: String| -> () {
+        debug_print(message);
+    })
+}

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

@@ -0,0 +1,22 @@
+use rquickjs::{Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx.clone(), move || -> () { drain_microtasks(&ctx) })
+}
+
+/// Executes all pending JavaScript jobs in the QuickJS job queue.
+///
+/// ### Remarks
+///
+/// These jobs are essentially JavaScript microtasks such as
+/// Promise then/catch/finally callbacks and the continuation of async functions after await points.
+/// In Azle on ICP, JavaScript macrotasks are essentially JavaScript executions
+/// that take place after the following:
+/// - The first JavaScript module execution in init/post_upgrade
+/// - JavaScript function execution of the developer-defined @init/@postUpgrade methods
+/// - JavaScript function execution from query/update/pre_upgrade/inspect_message/heartbeat/on_low_wasm_memory calls (execute_method_js)
+/// - JavaScript function execution from timer callbacks (set_timer/set_timer_interval),
+/// - JavaScript function execution in an inter-canister call's reply/reject callback
+pub fn drain_microtasks(ctx: &Ctx) {
+    while ctx.execute_pending_job() {}
+}

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

@@ -0,0 +1,6 @@
+use ic_cdk::api::in_replicated_execution;
+use rquickjs::{Ctx, Function, Result};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, || -> bool { in_replicated_execution() })
+}

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

@@ -0,0 +1,11 @@
+use candid::Principal;
+use ic_cdk::api::is_controller;
+use rquickjs::{Ctx, Function, Result, TypedArray};
+
+pub fn get_function(ctx: Ctx) -> Result<Function> {
+    Function::new(ctx, |principal_bytes: TypedArray<u8>| -> bool {
+        let principal = Principal::from_slice(principal_bytes.as_ref());
+
+        is_controller(&principal)
+    })
+}