stable/experimental binary bifurcation (rquickjs)

Cargo.toml

@@ -1,2 +1,6 @@
 [workspace]
-members = ["src/build/rust/canister", "src/build/rust/open_value_sharing"]
+members = [
+    "src/build/rust/canister",
+    "src/build/rust/open_value_sharing",
+    "src/build/rust/stable",
+]

src/build/rust/canister/src/candid.rs

@@ -37,7 +37,7 @@ pub fn get_candid_and_method_meta_pointer() -> *mut std::os::raw::c_char {
             // 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 = {EXPERIMENTAL};"));
-            context.eval_module_str(std::str::from_utf8(&js).unwrap().to_string(), "azle_main");
+            context.eval_module_str(std::str::from_utf8(&js).unwrap().to_string(), "main");
 
             run_event_loop(context);
 

src/build/rust/canister/src/execute_method_js.rs

@@ -16,6 +16,7 @@ pub extern "C" fn execute_method_js(function_index: i32, pass_arg_data: i32) {
             let global = context.get_global();
 
             let callbacks = global.get("_azleCallbacks");
+
             let method_callback = callbacks.get(function_name).unwrap();
 
             let candid_args = if pass_arg_data {

src/build/rust/canister/src/ic/mod.rs

@@ -312,5 +312,5 @@ pub fn register(context: &mut wasmedge_quickjs::Context) {
         context.new_function::<trap::NativeFunction>("").into(),
     );
 
-    context.get_global().set("_azleIc", ic.into());
+    context.get_global().set("_azleIcExperimental", ic.into());
 }

src/build/rust/canister/src/init_and_post_upgrade.rs

@@ -111,11 +111,11 @@ pub fn initialize_js(js: &str, init: bool, function_index: i32, pass_arg_data: i
         // 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 = {EXPERIMENTAL};"));
-        context.eval_module_str(js.to_string(), "azle_main");
+        context.eval_module_str(js.to_string(), "main");
 
         run_event_loop(context);
 
-        // let temp = context.eval_module_str(std::str::from_utf8(MAIN_JS).unwrap().to_string(), "azle_main");
+        // let temp = context.eval_module_str(std::str::from_utf8(MAIN_JS).unwrap().to_string(), "main");
 
         // match &temp {
         //     wasmedge_quickjs::JsValue::Exception(js_exception) => {

src/build/rust/stable/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "stable"
+version = "0.0.0"
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+candid = "0.10.2"
+candid_parser = "0.1.2"
+ic-cdk = "0.12.2"
+ic-cdk-macros = "0.8.4"
+ic-cdk-timers = "0.6.0"
+ic-stable-structures = "0.6.5"
+ic-wasi-polyfill = "0.6.1"
+rquickjs = { version = "0.6.2", features = ["array-buffer"] }
+serde = "1.0.202"
+serde_json = "1.0.107"
+slotmap = "=1.0.6"

src/build/rust/stable/src/candid.rs

@@ -0,0 +1,69 @@
+use crate::{
+    ic, quickjs_with_ctx, run_event_loop, wasm_binary_manipulation::get_js_code, CONTEXT_REF_CELL,
+    MODULE_NAME,
+};
+
+// TODO we might not need any of these panic hooks
+
+// Heavily inspired by https://stackoverflow.com/a/47676844
+#[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);
+    }));
+
+    let runtime = rquickjs::Runtime::new().unwrap();
+    let context = rquickjs::Context::full(&runtime).unwrap();
+
+    CONTEXT_REF_CELL.with(|context_ref_cell| {
+        *context_ref_cell.borrow_mut() = Some(context);
+    });
+
+    quickjs_with_ctx(|ctx| {
+        ctx.clone()
+            .globals()
+            .set("_azleNodeWasmEnvironment", true)
+            .unwrap();
+
+        ic::register(ctx.clone());
+
+        ctx.clone()
+            .globals()
+            .set("exports", rquickjs::Object::new(ctx.clone()).unwrap())
+            .unwrap();
+
+        ctx.clone()
+            .globals()
+            .set("_azleExperimental", false)
+            .unwrap();
+
+        let js = get_js_code();
+
+        // TODO is there a better name for this main module?
+        // TODO this returns a promise...make sure we handle it appropriately
+        rquickjs::Module::evaluate(ctx.clone(), MODULE_NAME, js).unwrap();
+
+        run_event_loop(ctx.clone());
+
+        let get_candid_and_method_meta: rquickjs::Function =
+            ctx.globals().get("_azleGetCandidAndMethodMeta").unwrap();
+
+        let candid_and_method_meta: String = get_candid_and_method_meta.call(()).unwrap();
+
+        let c_string = std::ffi::CString::new(candid_and_method_meta).unwrap();
+
+        c_string.into_raw()
+    })
+}

src/build/rust/stable/src/chunk.rs

@@ -0,0 +1,7 @@
+#[allow(unused)]
+pub async fn chunk() {
+    let id = ic_cdk::id();
+    let method = "_azle_chunk";
+    let args_raw = [68, 73, 68, 76, 0, 0]; // '()' pre encoded
+    let _ = ic_cdk::api::call::call_raw128(id, method, args_raw, 0).await;
+}

src/build/rust/stable/src/execute_method_js.rs

@@ -0,0 +1,26 @@
+use crate::{quickjs_with_ctx, run_event_loop};
+
+#[no_mangle]
+#[allow(unused)]
+pub extern "C" fn execute_method_js(function_index: i32, pass_arg_data: i32) {
+    let function_name = &function_index.to_string();
+    let pass_arg_data = if pass_arg_data == 1 { true } else { false };
+
+    quickjs_with_ctx(|ctx| {
+        let callbacks: rquickjs::Object = ctx.clone().globals().get("_azleCallbacks").unwrap();
+
+        let method_callback: rquickjs::Function = callbacks.get(function_name).unwrap();
+
+        let candid_args = if pass_arg_data {
+            ic_cdk::api::call::arg_data_raw()
+        } else {
+            vec![]
+        };
+
+        method_callback
+            .call::<_, rquickjs::Undefined>((candid_args,))
+            .unwrap();
+
+        run_event_loop(ctx.clone());
+    });
+}

src/build/rust/stable/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::caller()) {
+        return Ok(());
+    }
+    return Err(
+        "Not Authorized: only controllers of this canister may call this method".to_string(),
+    );
+}

src/build/rust/stable/src/ic/accept_message.rs

@@ -0,0 +1,8 @@
+use rquickjs::{Ctx, Function};
+
+pub fn get_function(context: Ctx) -> Function {
+    Function::new(context, || {
+        ic_cdk::api::call::accept_message();
+    })
+    .unwrap()
+}

src/build/rust/stable/src/ic/arg_data_raw.rs

@@ -0,0 +1,8 @@
+use rquickjs::{Ctx, Function, TypedArray};
+
+pub fn get_function(context: Ctx) -> Function {
+    Function::new(context.clone(), move || {
+        TypedArray::<u8>::new(context.clone(), ic_cdk::api::call::arg_data_raw())
+    })
+    .unwrap()
+}

src/build/rust/stable/src/ic/call_raw.rs

@@ -0,0 +1,96 @@
+use crate::{quickjs_with_ctx, run_event_loop};
+use rquickjs::{Ctx, Exception, Function, IntoJs, TypedArray};
+
+pub fn get_function(ctx: Ctx) -> Function {
+    Function::new(
+        ctx,
+        |promise_id: String,
+         canister_id_bytes: TypedArray<u8>,
+         method: String,
+         args_raw: TypedArray<u8>,
+         payment_string: String| {
+            let canister_id = candid::Principal::from_slice(canister_id_bytes.as_ref());
+            let args_raw = args_raw.as_bytes().unwrap().to_vec();
+            let payment: u128 = payment_string.parse().unwrap();
+
+            ic_cdk::spawn(async move {
+                let call_result =
+                    ic_cdk::api::call::call_raw128(canister_id, &method, args_raw, payment).await;
+
+                quickjs_with_ctx(move |ctx| {
+                    resolve_or_reject(ctx.clone(), &call_result, &promise_id);
+                    run_event_loop(ctx.clone());
+                });
+            });
+
+            rquickjs::Undefined
+        },
+    )
+    .unwrap()
+}
+
+fn resolve_or_reject<'a>(
+    ctx: Ctx<'a>,
+    call_result: &Result<Vec<u8>, (ic_cdk::api::call::RejectionCode, String)>,
+    promise_id: &str,
+) {
+    let (should_resolve, js_value) = prepare_js_value(ctx.clone(), &call_result);
+    let callback = get_callback(ctx.clone(), &promise_id, should_resolve);
+
+    callback
+        .call::<_, rquickjs::Undefined>((js_value,))
+        .unwrap();
+}
+
+fn prepare_js_value<'a>(
+    ctx: Ctx<'a>,
+    call_result: &Result<Vec<u8>, (ic_cdk::api::call::RejectionCode, String)>,
+) -> (bool, rquickjs::Value<'a>) {
+    match call_result {
+        Ok(candid_bytes) => {
+            let candid_bytes_js_value = TypedArray::<u8>::new(ctx.clone(), candid_bytes.clone())
+                .into_js(&ctx)
+                .unwrap();
+
+            (true, candid_bytes_js_value)
+        }
+        Err(err) => {
+            let err_js_value = Exception::from_message(
+                ctx.clone(),
+                &format!("Rejection code {}, {}", (err.0 as i32).to_string(), err.1),
+            )
+            .into_js(&ctx)
+            .unwrap();
+
+            (false, err_js_value)
+        }
+    }
+}
+
+fn get_callback<'a>(
+    ctx: Ctx<'a>,
+    promise_id: &str,
+    should_resolve: bool,
+) -> rquickjs::Function<'a> {
+    let global_object = get_resolve_or_reject_global_object(ctx.clone(), should_resolve);
+    let callback_name = get_resolve_or_reject_callback_name(&promise_id, should_resolve);
+
+    global_object.get(callback_name).unwrap()
+}
+
+fn get_resolve_or_reject_global_object(ctx: Ctx, should_resolve: bool) -> rquickjs::Object {
+    let global = ctx.globals();
+    if should_resolve {
+        global.get("_azleResolveIds").unwrap()
+    } else {
+        global.get("_azleRejectIds").unwrap()
+    }
+}
+
+fn get_resolve_or_reject_callback_name(promise_id: &str, should_resolve: bool) -> String {
+    if should_resolve {
+        format!("_resolve_{promise_id}")
+    } else {
+        format!("_reject_{promise_id}")
+    }
+}

src/build/rust/stable/src/ic/caller.rs

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

src/build/rust/stable/src/ic/candid_compiler.rs

@@ -0,0 +1,11 @@
+use rquickjs::{Ctx, Function};
+use std::path::Path;
+
+pub fn get_function(context: Ctx) -> Function {
+    Function::new(context, |candid_path: String| {
+        let (env, actor) = candid_parser::pretty_check_file(Path::new(&candid_path)).unwrap();
+
+        candid_parser::bindings::javascript::compile(&env, &actor)
+    })
+    .unwrap()
+}

src/build/rust/stable/src/ic/candid_decode.rs

@@ -0,0 +1,12 @@
+use rquickjs::{Ctx, Function, TypedArray};
+
+pub fn get_function(context: Ctx) -> Function {
+    Function::new(context, |candid_encoded: TypedArray<u8>| {
+        let candid_bytes = candid_encoded.as_ref();
+        let candid_args: candid::IDLArgs = candid::IDLArgs::from_bytes(candid_bytes).unwrap();
+        let candid_string = candid_args.to_string();
+
+        candid_string
+    })
+    .unwrap()
+}