@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/build/commands/build/get_context.ts

@@ -0,0 +1,61 @@
+import '#experimental/build/assert_experimental';
+
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+import { getContext as getStableContext } from '#commands/build/get_context';
+import { Context, WasmData } from '#experimental/utils/types';
+import { CanisterConfig } from '#experimental/utils/types';
+import { getCanisterId } from '#utils/dfx';
+import { AZLE_ROOT } from '#utils/global_paths';
+
+export async function getContext(
+    canisterName: string,
+    canisterConfig: CanisterConfig
+): Promise<Context> {
+    const stableContext = await getStableContext(canisterName, {
+        ...canisterConfig,
+        custom: {
+            ...canisterConfig.custom,
+            assets: undefined,
+            build_assets: undefined,
+            esm_aliases: undefined,
+            esm_externals: undefined
+        }
+    });
+
+    const canisterId = getCanisterId(canisterName);
+
+    const esmAliases = canisterConfig.custom?.esm_aliases ?? {};
+    const esmExternals = canisterConfig.custom?.esm_externals ?? [];
+
+    const reloadedJsPath = join('.azle', canisterName, 'main_reloaded.js');
+
+    const managementDid = (
+        await readFile(
+            join(
+                AZLE_ROOT,
+                'src',
+                'stable',
+                'lib',
+                'canisters',
+                'management',
+                'idl',
+                'ic.did'
+            )
+        )
+    ).toString();
+    const wasmData: WasmData = {
+        ...stableContext.wasmData,
+        managementDid
+    };
+
+    return {
+        ...stableContext,
+        canisterId,
+        esmAliases,
+        esmExternals,
+        reloadedJsPath,
+        wasmData
+    };
+}

package/src/experimental/build/commands/build/index.ts

@@ -0,0 +1,87 @@
+import '#experimental/build/assert_experimental';
+
+import { IOType } from 'child_process';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { dirname, join } from 'path';
+
+import { logSuccess } from '#experimental/utils/log_success';
+import { CanisterConfig } from '#experimental/utils/types';
+import { execSyncPretty } from '#utils/exec_sync_pretty';
+
+import { getCandidAndMethodMeta } from './candid_and_method_meta';
+import { setupFileWatcher } from './file_watcher/setup_file_watcher';
+import { getContext } from './get_context';
+import { compile as compileJavaScript } from './javascript';
+import { getWasmBinary } from './wasm_binary';
+
+export async function runCommand(
+    canisterName: string,
+    canisterConfig: CanisterConfig,
+    ioType: IOType
+): Promise<void> {
+    const {
+        canisterId,
+        canisterPath,
+        candidPath,
+        esmAliases,
+        esmExternals,
+        main,
+        reloadedJsPath,
+        wasmBinaryPath,
+        wasmData
+    } = await getContext(canisterName, canisterConfig);
+
+    await rm(canisterPath, { recursive: true, force: true });
+
+    const javaScript = await compileJavaScript(main, esmAliases, esmExternals);
+
+    const mainJsPath = join(canisterPath, 'main.js');
+    await mkdir(dirname(mainJsPath), { recursive: true });
+    await writeFile(mainJsPath, javaScript);
+
+    const { candid, methodMeta } = await getCandidAndMethodMeta(
+        canisterConfig.custom?.candid_gen,
+        candidPath,
+        javaScript,
+        ioType,
+        wasmData
+    );
+
+    await mkdir(dirname(candidPath), { recursive: true });
+    await writeFile(candidPath, candid);
+
+    const wasmBinary = await getWasmBinary(
+        ioType,
+        javaScript,
+        wasmData,
+        methodMeta
+    );
+
+    await mkdir(dirname(wasmBinaryPath), { recursive: true });
+    await writeFile(wasmBinaryPath, wasmBinary);
+
+    buildAssets(canisterConfig, ioType);
+
+    setupFileWatcher(
+        reloadedJsPath,
+        canisterId,
+        main,
+        esmAliases,
+        esmExternals,
+        canisterName,
+        methodMeta.post_upgrade?.index ?? -1
+    );
+
+    logSuccess(canisterName, canisterId);
+}
+
+function buildAssets(canisterConfig: CanisterConfig, ioType: IOType): void {
+    if (
+        canisterConfig.custom?.build_assets !== undefined &&
+        canisterConfig.custom?.build_assets !== null
+    ) {
+        execSyncPretty(canisterConfig.custom.build_assets, {
+            stdio: ioType
+        });
+    }
+}

package/src/experimental/build/commands/build/javascript.ts

@@ -0,0 +1,194 @@
+import '#experimental/build/assert_experimental';
+
+import { BuildOptions } from 'esbuild';
+import esbuildPluginTsc from 'esbuild-plugin-tsc';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+import {
+    bundle,
+    getBuildOptions as getStableBuildOptions,
+    handleClassApiCanister
+} from '#commands/build/javascript';
+import { findProjectRoot } from '#experimental/build/utils/find_project_root';
+import { WASMEDGE_QUICKJS_PATH } from '#experimental/utils/global_paths';
+import { getDfxRoot } from '#utils/dfx_root';
+import { AZLE_ROOT } from '#utils/global_paths';
+
+export async function compile(
+    main: string,
+    esmAliases: Record<string, string>,
+    esmExternals: string[]
+): Promise<string> {
+    const prelude = getPrelude(main);
+    const buildOptions = await getBuildOptions(
+        prelude,
+        main,
+        esmAliases,
+        esmExternals
+    );
+    const bundled = await bundle(buildOptions);
+
+    return bundled
+        .replace(
+            /__toCommonJS\(assert_exports\)\);/g,
+            `__toCommonJS(assert_exports)).default;`
+        )
+        .replace(
+            /__toCommonJS\(stream_exports\)\);/g,
+            `__toCommonJS(stream_exports)).default;`
+        )
+        .replace(
+            /__toCommonJS\(http_exports\)\);/g,
+            `__toCommonJS(http_exports)).default;`
+        );
+}
+
+export function getPrelude(main: string): string {
+    const absoluteMainPath = join(getDfxRoot(), main);
+    return /*TS*/ `
+        import 'azle/_internal/globals';
+        import 'azle/experimental/_internal/globals';
+
+        import 'reflect-metadata';
+
+        import { getDefaultVisitorData, IDL, idlToString } from 'azle';
+        import { ethersGetUrl, Server } from 'azle/experimental';
+        import { ethers } from 'ethers';
+
+        // TODO remove the ethersGetUrl registration once we implement lower-level http for ethers
+        ethers.FetchRequest.registerGetUrl(ethersGetUrl);
+
+        export { Principal } from '@dfinity/principal';
+        import * as CanisterModuleExperimental from '${absoluteMainPath}';
+
+        const somethingDefaultExported = CanisterModuleExperimental.default !== undefined && CanisterModuleExperimental.default !== null;
+
+        if (somethingDefaultExported === true) {
+            createGetCandidAndMethodMetaFunction(CanisterModuleExperimental);
+        }
+        else {
+            // TODO This setTimeout is here to allow asynchronous operations during canister initialization
+            // for Server canisters that have chosen not to use export default class extends Server
+            // This seems to work no matter how many async tasks are awaited, but I am still unsure about how it will
+            // behave in all async situations
+            setTimeout(() => {
+                class ServerCanister extends Server {
+                    constructor() {
+                        super();
+
+                        this.nodeServer = globalThis._azleNodeServer;
+                    }
+                }
+
+                const CanisterModuleExperimentalServer = {
+                    default: ServerCanister
+                };
+
+                createGetCandidAndMethodMetaFunction(CanisterModuleExperimentalServer);
+            });
+        }
+
+        ${handleClassApiCanister(main)}
+    `;
+}
+
+export async function getBuildOptions(
+    ts: string,
+    main: string,
+    esmAliases: Record<string, string>,
+    esmExternals: string[]
+): Promise<BuildOptions> {
+    const externalImplemented = [
+        '_node:fs',
+        '_node:os',
+        '_node:crypto',
+        'qjs:os',
+        '_encoding',
+        'wasi_net',
+        'wasi_http'
+    ];
+
+    // These are modules that should not be included in the build from the Azle side (our side)
+    const externalNotImplementedAzle: string[] = [];
+
+    // These are modules that should not be included in the build from the developer side
+    // These are specified in the dfx.json canister object esm_externals property
+    const externalNotImplementedDev = esmExternals;
+
+    // These will cause runtime errors if their functionality is dependend upon
+    const externalNotImplemented = [
+        ...externalNotImplementedAzle,
+        ...externalNotImplementedDev
+    ];
+
+    const customJsModulesPath = join(
+        AZLE_ROOT,
+        'src',
+        'experimental',
+        'build',
+        'commands',
+        'build',
+        'custom_js_modules'
+    );
+
+    const stableBuildOptions = getStableBuildOptions(ts, main);
+
+    return {
+        ...stableBuildOptions,
+        // It seems that the version of QuickJS that wasmedge-quickjs uses in Azle does not support some syntax from es2024.
+        // Thus we are pegging the target to es2021. We will eventually get rid of wasmedge-quickjs and just use rquickjs for experimental anyway.
+        target: 'es2021',
+        alias: {
+            internal: `${WASMEDGE_QUICKJS_PATH}/modules/internal`,
+            util: `${WASMEDGE_QUICKJS_PATH}/modules/util`,
+            fs: `${WASMEDGE_QUICKJS_PATH}/modules/fs`,
+            fmt: `${WASMEDGE_QUICKJS_PATH}/modules/fmt`,
+            assert: `${WASMEDGE_QUICKJS_PATH}/modules/assert.js`,
+            buffer: `${WASMEDGE_QUICKJS_PATH}/modules/buffer.js`,
+            path: `${WASMEDGE_QUICKJS_PATH}/modules/path.js`,
+            stream: `${WASMEDGE_QUICKJS_PATH}/modules/stream.js`,
+            process: `${WASMEDGE_QUICKJS_PATH}/modules/process.js`,
+            url: `${WASMEDGE_QUICKJS_PATH}/modules/url.js`,
+            events: `${WASMEDGE_QUICKJS_PATH}/modules/events.js`,
+            string_decoder: `${WASMEDGE_QUICKJS_PATH}/modules/string_decoder.js`,
+            punycode: `${WASMEDGE_QUICKJS_PATH}/modules/punycode.js`,
+            querystring: `${WASMEDGE_QUICKJS_PATH}/modules/querystring.js`,
+            whatwg_url: `${WASMEDGE_QUICKJS_PATH}/modules/whatwg_url.js`,
+            encoding: `${WASMEDGE_QUICKJS_PATH}/modules/encoding.js`,
+            http: `${WASMEDGE_QUICKJS_PATH}/modules/http.js`,
+            os: `${WASMEDGE_QUICKJS_PATH}/modules/os.js`,
+            // crypto: `${WASMEDGE_QUICKJS_PATH}/modules/crypto.js`, // TODO waiting on wasi-crypto
+            crypto: 'crypto-browserify', // TODO we really want the wasmedge-quickjs version once wasi-crypto is working
+            zlib: 'pako',
+            'internal/deps/acorn/acorn/dist/acorn': join(
+                customJsModulesPath,
+                'acorn',
+                'acorn.ts'
+            ), // TODO acorn stuff is a bug, wasmedge-quickjs should probably add these files
+            'internal/deps/acorn/acorn-walk/dist/walk': join(
+                customJsModulesPath,
+                'acorn',
+                'walk.ts'
+            ), // TODO acorn stuff is a bug, wasmedge-quickjs should probably add these files
+            perf_hooks: join(customJsModulesPath, 'perf_hooks.ts'),
+            async_hooks: join(customJsModulesPath, 'async_hooks.ts'),
+            https: join(customJsModulesPath, 'https.ts'),
+            ...esmAliases
+        },
+        external: [...externalImplemented, ...externalNotImplemented],
+        // I believe the esbuildPluginTsc is here to honor the reflect-metadata import and thus to enable experimental decorators.
+        // I am not sure about this.
+        plugins: [esbuildPluginTsc({ tsconfigPath: await getTsConfigPath() })]
+    };
+}
+
+export async function getTsConfigPath(): Promise<string> {
+    const projectRoot = await findProjectRoot();
+    const tsConfigPath = join(projectRoot, 'tsconfig.json');
+
+    if (existsSync(tsConfigPath)) {
+        return tsConfigPath;
+    }
+    return join(AZLE_ROOT, 'tsconfig.dev.json');
+}

package/src/experimental/build/commands/build/wasm_binary/index.ts

@@ -0,0 +1,32 @@
+import '#experimental/build/assert_experimental';
+
+import { IOType } from 'child_process';
+import { existsSync } from 'fs';
+
+import { runCommand as runDevTemplateCommand } from '#build/commands/dev/template/experimental';
+import { manipulateWasmBinary } from '#commands/build/wasm_binary/manipulate';
+import { WasmData } from '#experimental/utils/types';
+import { EXPERIMENTAL_STATIC_CANISTER_TEMPLATE_PATH } from '#utils/global_paths';
+import { MethodMeta } from '#utils/types';
+
+export async function getWasmBinary(
+    ioType: IOType,
+    js: string,
+    wasmData: WasmData,
+    methodMeta?: MethodMeta
+): Promise<Uint8Array> {
+    if (
+        process.env.AZLE_DEV_TEMPLATE === 'true' ||
+        !existsSync(EXPERIMENTAL_STATIC_CANISTER_TEMPLATE_PATH)
+    ) {
+        await runDevTemplateCommand(ioType);
+    }
+
+    return await manipulateWasmBinary<WasmData>(
+        js,
+        EXPERIMENTAL_STATIC_CANISTER_TEMPLATE_PATH,
+        wasmData,
+        false,
+        methodMeta
+    );
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "experimental_canister_template"
+version = "0.0.0"
+edition = "2024"
+license-file = "../../../../../../../../LICENSE"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = { workspace = true }
+ic-cdk = { workspace = true }
+ic-cdk-timers = { workspace = true }
+candid = { workspace = true }
+candid_parser = { workspace = true }
+ic-stable-structures = { workspace = true }
+peak_alloc = { workspace = true }
+rand = { workspace = true }
+scopeguard = { workspace = true }
+slotmap = { workspace = true }
+sha2 = "0.10.9"
+serde = { workspace = true }
+serde_json = { workspace = true }
+ic-wasi-polyfill = { workspace = true }
+wasmedge_quickjs = { git = "https://github.com/demergent-labs/wasmedge-quickjs", rev = "573c6c07316de64e4bb9a9561b079f265fd9bcc4" }
+wasmi = "0.51.0"

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/autoreload.rs

@@ -0,0 +1,46 @@
+use std::{cell::RefCell, collections::BTreeMap};
+
+use crate::{init_and_post_upgrade::initialize_js, WASM_DATA_REF_CELL};
+
+thread_local! {
+    static RELOADED_JS_TIMESTAMP: RefCell<u64> = RefCell::new(0);
+    static RELOADED_JS: RefCell<BTreeMap<u64, Vec<u8>>> = RefCell::new(BTreeMap::new());
+}
+
+pub fn reload_js(
+    timestamp: u64,
+    chunk_number: u64,
+    js_bytes: Vec<u8>,
+    total_len: u64,
+    function_index: i32,
+) {
+    RELOADED_JS_TIMESTAMP.with(|reloaded_js_timestamp| {
+        let mut reloaded_js_timestamp_mut = reloaded_js_timestamp.borrow_mut();
+
+        if timestamp > *reloaded_js_timestamp_mut {
+            *reloaded_js_timestamp_mut = timestamp;
+
+            RELOADED_JS.with(|reloaded_js| {
+                let mut reloaded_js_mut = reloaded_js.borrow_mut();
+                reloaded_js_mut.clear();
+            });
+        }
+    });
+
+    RELOADED_JS.with(|reloaded_js| {
+        let mut reloaded_js_mut = reloaded_js.borrow_mut();
+        reloaded_js_mut.insert(chunk_number, js_bytes);
+
+        let reloaded_js_complete_bytes: Vec<u8> =
+            reloaded_js_mut.values().flat_map(|v| v.clone()).collect();
+
+        if reloaded_js_complete_bytes.len() as u64 == total_len {
+            let wasm_data = WASM_DATA_REF_CELL
+                .with(|wasm_data_ref_cell| wasm_data_ref_cell.borrow().as_ref().unwrap().clone());
+
+            let js_string = String::from_utf8_lossy(&reloaded_js_complete_bytes);
+            initialize_js(&wasm_data, &js_string, false, function_index);
+            ic_cdk::println!("Azle: Reloaded canister JavaScript");
+        }
+    });
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/benchmarking.rs

@@ -0,0 +1,35 @@
+use std::cell::RefCell;
+
+use candid::CandidType;
+use wasmedge_quickjs::{AsObject, Context};
+
+#[derive(CandidType, Debug, Clone)]
+pub struct BenchmarkEntry {
+    pub method_name: String,
+    pub instructions: u64,
+    pub timestamp: u64,
+}
+
+thread_local! {
+    pub static BENCHMARKS_REF_CELL: RefCell<Vec<BenchmarkEntry>> = RefCell::new(Vec::new());
+}
+
+pub fn record_benchmark(context: &mut Context, function_name: &str, instructions: u64) {
+    let timestamp = ic_cdk::api::time();
+
+    let global = context.get_global();
+    let method_names = global.get("_azleCanisterMethodNames");
+    let method_name = method_names
+        .get(function_name)
+        .and_then(|v| Some(v.to_string()?.to_string()))
+        .unwrap_or_else(|| function_name.to_string());
+
+    BENCHMARKS_REF_CELL.with(|benchmarks_ref_cell| {
+        let mut benchmarks = benchmarks_ref_cell.borrow_mut();
+        benchmarks.push(BenchmarkEntry {
+            method_name,
+            instructions,
+            timestamp,
+        });
+    });
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/candid.rs

@@ -0,0 +1,106 @@
+use wasmedge_quickjs::AsObject;
+
+use crate::{
+    RUNTIME, ic,
+    ic::drain_microtasks,
+    wasm_binary_manipulation::{get_js_code, get_wasm_data},
+};
+
+// Heavily inspired by https://stackoverflow.com/a/47676844
+#[unsafe(no_mangle)]
+pub fn get_candid_and_method_meta_pointer() -> *mut std::os::raw::c_char {
+    std::panic::set_hook(Box::new(|panic_info| {
+        let msg = match panic_info.payload().downcast_ref::<&str>() {
+            Some(s) => *s,
+            None => "Unknown panic message",
+        };
+        let location = if let Some(location) = panic_info.location() {
+            format!(" at {}:{}", location.file(), location.line())
+        } else {
+            " (unknown location)".to_string()
+        };
+
+        let message = &format!("Panic occurred: {}{}", msg, location);
+
+        ic_cdk::println!("{}", message);
+    }));
+
+    RUNTIME.with(|_| {
+        let mut runtime = wasmedge_quickjs::Runtime::new();
+
+        runtime.run_with_context(|context| {
+            context
+                .get_global()
+                .set("_azleActions", context.new_array().into());
+
+            context.get_global().set(
+                "_azleNodejsWasmEnvironment",
+                wasmedge_quickjs::JsValue::Bool(true),
+            );
+
+            context
+                .get_global()
+                .set("_azleCanisterMethodNames", context.new_object().into());
+
+            context.get_global().set(
+                "_azleIcpReplicaWasmEnvironment",
+                wasmedge_quickjs::JsValue::Bool(false),
+            );
+
+            context
+                .get_global()
+                .set("_azleTimerCallbacks", context.new_object().into());
+
+            context
+                .get_global()
+                .set("_azleRejectCallbacks", context.new_object().into());
+
+            context
+                .get_global()
+                .set("_azleResolveCallbacks", context.new_object().into());
+
+            ic::register(context);
+
+            let wasm_data = get_wasm_data();
+            let js = get_js_code();
+
+            // TODO what do we do if there is an error in here?
+            context.eval_global_str("globalThis.exports = {};".to_string());
+            context.eval_global_str(format!("globalThis._azleExperimental = true;"));
+            context.eval_module_str(
+                std::str::from_utf8(&js).unwrap().to_string(),
+                &wasm_data.main_js_path,
+            );
+
+            drain_microtasks(context);
+
+            let global = context.get_global();
+
+            let get_candid_and_method_meta = global
+                .get("_azleGetCandidAndMethodMeta")
+                .to_function()
+                .unwrap();
+
+            let candid_and_method_meta = get_candid_and_method_meta.call(&[]);
+
+            // TODO error handling is mostly done in JS right now
+            // TODO we would really like wasmedge-quickjs to add
+            // TODO good error info to JsException and move error handling
+            // TODO out of our own code
+            match &candid_and_method_meta {
+                wasmedge_quickjs::JsValue::Exception(js_exception) => {
+                    js_exception.dump_error();
+                    panic!("TODO needs error info");
+                }
+                _ => drain_microtasks(context),
+            };
+
+            let candid_and_method_meta_string =
+                candid_and_method_meta.to_string().unwrap().to_string();
+
+            let c_string = std::ffi::CString::new(candid_and_method_meta_string).unwrap();
+
+            c_string.into_raw()
+        })
+    })
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/chunk.rs

@@ -0,0 +1,11 @@
+#[allow(unused)]
+pub async fn chunk() {
+    let id = ic_cdk::api::canister_self();
+    let method = "_azle_chunk";
+    let args_raw = [68, 73, 68, 76, 0, 0]; // pre-encoded Candid empty params
+    let call_result = ic_cdk::call::Call::unbounded_wait(id, method)
+        .with_raw_args(&args_raw)
+        .await;
+
+    call_result.unwrap();
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/execute_method_js.rs

@@ -0,0 +1,46 @@
+use std::env::var;
+
+use wasmedge_quickjs::AsObject;
+
+use crate::{RUNTIME, benchmarking::record_benchmark, ic::drain_microtasks};
+
+#[unsafe(no_mangle)]
+#[allow(unused)]
+pub extern "C" fn execute_method_js(function_index: i32) {
+    ic_cdk::futures::in_executor_context(|| {
+        let function_name = function_index.to_string();
+
+        RUNTIME.with(|runtime| {
+            let mut runtime = runtime.borrow_mut();
+            let runtime = runtime.as_mut().unwrap();
+
+            runtime.run_with_context(|context| {
+                let global = context.get_global();
+
+                let canister_class_meta = global.get("_azleCanisterClassMeta");
+
+                let callbacks = canister_class_meta.get("callbacks").unwrap();
+
+                let method_callback = callbacks.get(&function_name).unwrap();
+
+                let method_callback_function = method_callback.to_function().unwrap();
+                let result = method_callback_function.call(&[]);
+
+                match &result {
+                    wasmedge_quickjs::JsValue::Exception(js_exception) => {
+                        js_exception.dump_error();
+                        panic!("TODO needs error info");
+                    }
+                    _ => drain_microtasks(context),
+                };
+
+                if let Ok(azle_record_benchmarks) = var("AZLE_RECORD_BENCHMARKS") {
+                    if azle_record_benchmarks == "true" {
+                        let instructions = ic_cdk::api::performance_counter(1);
+                        record_benchmark(context, &function_name, instructions);
+                    }
+                }
+            });
+        });
+    });
+}

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/guards.rs

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

package/src/experimental/build/commands/build/wasm_binary/rust/experimental_canister_template/src/ic/accept_message.rs

@@ -0,0 +1,10 @@
+use wasmedge_quickjs::{Context, JsFn, JsValue};
+
+pub struct NativeFunction;
+impl JsFn for NativeFunction {
+    fn call(_context: &mut Context, _this_val: JsValue, _argv: &[JsValue]) -> JsValue {
+        ic_cdk::api::accept_message();
+
+        JsValue::UnDefined
+    }
+}