diff --git a/crates/svm-wasmer-c-api/Cargo.lock b/crates/svm-wasmer-c-api/Cargo.lock
index ec6085457..93f41b064 100644
--- a/crates/svm-wasmer-c-api/Cargo.lock
+++ b/crates/svm-wasmer-c-api/Cargo.lock
@@ -630,6 +630,7 @@ dependencies = [
  "wasmer-runtime 0.6.0 (git+https://github.com/spacemeshos/wasmer?branch=develop)",
  "wasmer-runtime-c-api 0.6.0 (git+https://github.com/spacemeshos/wasmer?branch=develop)",
  "wasmer-runtime-core 0.6.0 (git+https://github.com/spacemeshos/wasmer?branch=develop)",
+ "wasmer-singlepass-backend 0.6.0 (git+https://github.com/spacemeshos/wasmer?branch=develop)",
 ]
 
 [[package]]
diff --git a/crates/svm-wasmer-c-api/examples/counter.c b/crates/svm-wasmer-c-api/examples/counter.c
index 268763a81..3cc4fefeb 100644
--- a/crates/svm-wasmer-c-api/examples/counter.c
+++ b/crates/svm-wasmer-c-api/examples/counter.c
@@ -116,7 +116,7 @@ int main() {
     assert(compile_res == WASMER_OK);
 
     wasmer_instance_t *instance = NULL;
-    wasmer_result_t instance_res = wasmer_svm_module_instantiate(&instance, module, import_object);
+    wasmer_result_t instance_res = wasmer_module_import_instantiate(&instance, module, import_object);
     assert(instance_res == WASMER_OK);
 
     // First we want to assert that the counter has been initialized with `9`
diff --git a/crates/svm-wasmer-c-api/examples/libwasmer_runtime_c_api.dylib b/crates/svm-wasmer-c-api/examples/libwasmer_runtime_c_api.dylib
index 52123f703..a1b0cfd24 100755
Binary files a/crates/svm-wasmer-c-api/examples/libwasmer_runtime_c_api.dylib and b/crates/svm-wasmer-c-api/examples/libwasmer_runtime_c_api.dylib differ
diff --git a/crates/svm-wasmer-c-api/examples/svm_wasmer.h b/crates/svm-wasmer-c-api/examples/svm_wasmer.h
index 65827b3c3..9579b4403 100644
--- a/crates/svm-wasmer-c-api/examples/svm_wasmer.h
+++ b/crates/svm-wasmer-c-api/examples/svm_wasmer.h
@@ -7,10 +7,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-typedef struct {
-
-} wasmer_import_object_t;
-
 /**
  * Returns a pointer to the `svm context node_data`.
  * It will be used by the node vmcalls implementation.
@@ -46,24 +42,4 @@ wasmer_result_t wasmer_svm_import_object(wasmer_import_object_t** import_object,
                                          wasmer_import_t *imports,
                                          uint32_t imports_len);
 
-
-/**
- * Given a compiler wasmer module (param `module`) and a ready-made import object (param `import_object`),
- * instantiates a new wasmer instance.
- * The instance is returned via the param `instance` (that's why it's of type `wasmer_instance_t**`)
- *
- * Returns `wasmer_result_t::WASMER_OK` upon success.
- * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
- * and `wasmer_last_error_message` to get an error message.
- */
-wasmer_result_t wasmer_svm_module_instantiate(wasmer_instance_t** instance,
-                                              wasmer_module_t* module,
-                                              wasmer_import_object_t* import_object);
-
-
-/**
- * Frees memory of the given ImportObject
- */
-void wasmer_import_object_destroy(wasmer_import_object_t* import_object);
-
 #endif /* WASMER_SVM_H */
diff --git a/crates/svm-wasmer-c-api/examples/wasmer.h b/crates/svm-wasmer-c-api/examples/wasmer.h
index b911ee1e6..11c6cb0ce 100644
--- a/crates/svm-wasmer-c-api/examples/wasmer.h
+++ b/crates/svm-wasmer-c-api/examples/wasmer.h
@@ -95,11 +95,7 @@ typedef struct {
 
 typedef struct {
 
-} wasmer_instance_t;
-
-typedef struct {
-
-} wasmer_instance_context_t;
+} wasmer_import_object_t;
 
 typedef struct {
 
@@ -119,6 +115,14 @@ typedef struct {
   wasmer_import_export_value value;
 } wasmer_import_t;
 
+typedef struct {
+
+} wasmer_instance_t;
+
+typedef struct {
+
+} wasmer_instance_context_t;
+
 typedef struct {
   bool has_some;
   uint32_t some;
@@ -392,6 +396,24 @@ wasmer_result_t wasmer_import_func_returns(const wasmer_import_func_t *func,
 wasmer_result_t wasmer_import_func_returns_arity(const wasmer_import_func_t *func,
                                                  uint32_t *result);
 
+/**
+ * Frees memory of the given ImportObject
+ */
+void wasmer_import_object_destroy(wasmer_import_object_t *import_object);
+
+/**
+ * Extends an existing import object with new imports
+ */
+wasmer_result_t wasmer_import_object_extend(wasmer_import_object_t *import_object,
+                                            wasmer_import_t *imports,
+                                            unsigned int imports_len);
+
+/**
+ * Creates a new empty import object.
+ * See also `wasmer_import_object_append`
+ */
+wasmer_import_object_t *wasmer_import_object_new(void);
+
 /**
  * Calls an instances exported function by `name` with the provided parameters.
  * Results are set using the provided `results` pointer.
@@ -531,6 +553,16 @@ wasmer_result_t wasmer_module_deserialize(wasmer_module_t **module,
  */
 void wasmer_module_destroy(wasmer_module_t *module);
 
+/**
+ * Given:
+ *  A prepared `wasmer svm` import-object
+ *  A compiled wasmer module
+ * Instantiates a wasmer instance
+ */
+wasmer_result_t wasmer_module_import_instantiate(wasmer_instance_t **instance,
+                                                 const wasmer_module_t *module,
+                                                 const wasmer_import_object_t *import_object);
+
 /**
  * Creates a new Instance from the given module and imports.
  * Returns `wasmer_result_t::WASMER_OK` upon success.
diff --git a/crates/svm-wasmer-c-api/src/import.rs b/crates/svm-wasmer-c-api/src/import.rs
deleted file mode 100644
index 1bd07430c..000000000
--- a/crates/svm-wasmer-c-api/src/import.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use wasmer_runtime::ImportObject;
-
-/// A marker for the C representation of `ImportObject`
-#[repr(C)]
-pub struct wasmer_import_object_t;
-
-/// Frees memory of the given ImportObject
-#[no_mangle]
-pub extern "C" fn wasmer_import_object_destroy(import_object: *mut wasmer_import_object_t) {
-    if !import_object.is_null() {
-        unsafe { Box::from_raw(import_object as *mut ImportObject) };
-    }
-}
diff --git a/crates/svm-wasmer-c-api/src/lib.rs b/crates/svm-wasmer-c-api/src/lib.rs
index 8bfc8417c..4fd92243d 100644
--- a/crates/svm-wasmer-c-api/src/lib.rs
+++ b/crates/svm-wasmer-c-api/src/lib.rs
@@ -4,9 +4,6 @@
 
 //! This crate is responsible on providing a [FFI](https://doc.rust-lang.org/nomicon/ffi.html) interface for the `wasmer svm`.
 
-/// Contains a definition for `wasmer_import_object_t`
-pub mod import;
-
 /// Will contain macros for the `svm wasmer C-API`
 pub mod macros;
 
diff --git a/crates/svm-wasmer-c-api/src/macros.rs b/crates/svm-wasmer-c-api/src/macros.rs
index aa4ff0d11..061a7568f 100644
--- a/crates/svm-wasmer-c-api/src/macros.rs
+++ b/crates/svm-wasmer-c-api/src/macros.rs
@@ -7,13 +7,11 @@ macro_rules! include_svm_wasmer_c_api {
     ($KV:ident, $PS:ident, $PC:ident) => {
         use std::ffi::c_void;
 
-        use crate::import::wasmer_import_object_t;
-
         use wasmer_runtime::{imports, Ctx, ImportObject, Instance, Module};
         use wasmer_runtime_c_api::{
             error::{update_last_error, CApiError},
             export::wasmer_import_export_kind,
-            import::wasmer_import_t,
+            import::{wasmer_import_object_extend, wasmer_import_object_t, wasmer_import_t},
             instance::{wasmer_instance_context_t, wasmer_instance_t},
             module::wasmer_module_t,
             wasmer_result_t,
@@ -62,45 +60,19 @@ macro_rules! include_svm_wasmer_c_api {
             wasmer_data_node_data!(wasmer_ctx.data, $PC)
         }
 
-        /// Given:
-        /// * A prepared `wasmer svm` import-object
-        /// * A compiled wasmer module
-        ///
-        /// Instantiates a wasmer instance
-        #[no_mangle]
-        pub unsafe extern "C" fn wasmer_svm_module_instantiate(
-            instance_ptr_ptr: *mut *mut wasmer_instance_t,
-            module: *const wasmer_module_t,
-            import_object: *const wasmer_import_object_t,
-        ) -> wasmer_runtime_c_api::wasmer_result_t {
-            let import_object: &ImportObject = &*(import_object as *const ImportObject);
-            let module: &Module = &*(module as *const Module);
-
-            let new_instance: Instance = match module.instantiate(import_object) {
-                Ok(instance) => instance,
-                Err(error) => {
-                    update_last_error(error);
-                    return wasmer_result_t::WASMER_ERROR;
-                }
-            };
-            *instance_ptr_ptr = Box::into_raw(Box::new(new_instance)) as *mut wasmer_instance_t;
-
-            return wasmer_result_t::WASMER_OK;
-        }
-
         /// Creates a new `wasmer` import object.
         /// The import object will include imports of two flavors:
         /// * external vmcalls (i.e: node vmcalls)
         /// * internal vmcalls (i.e: register/storage/etc vmcalls)
         #[no_mangle]
         pub unsafe extern "C" fn wasmer_svm_import_object(
-            imprt_obj_ptr_ptr: *mut *mut wasmer_import_object_t,
+            raw_import_object: *mut *mut wasmer_import_object_t,
             addr_ptr: *const u8,
             max_pages: libc::c_int,
             max_page_slices: libc::c_int,
             node_data_ptr: *const c_void,
             imports: *mut wasmer_import_t,
-            imports_len: libc::c_int,
+            imports_len: libc::c_uint,
         ) -> wasmer_runtime_c_api::wasmer_result_t {
             use wasmer_runtime::ImportObject;
 
@@ -114,18 +86,16 @@ macro_rules! include_svm_wasmer_c_api {
                 max_page_slices as usize
             );
 
-            let mut import_obj = ImportObject::new_with_data(state_gen);
-
-            append_internal_imports(&mut import_obj);
+            let mut import_object = ImportObject::new_with_data(state_gen);
+            append_internal_imports(&mut import_object);
 
-            let _res = append_external_imports(&mut import_obj, imports, imports_len);
+            *raw_import_object = cast_import_obj_to_ptr(import_object);
+            let _res = wasmer_import_object_extend(*raw_import_object, imports, imports_len);
             // TODO: assert result
             // if res != wasmer_result_t::WASMER_OK {
             //     return res;
             // }
 
-            *imprt_obj_ptr_ptr = cast_import_obj_to_ptr(import_obj);
-
             wasmer_result_t::WASMER_OK
         }
 
@@ -141,68 +111,10 @@ macro_rules! include_svm_wasmer_c_api {
             import_obj.register("svm", ns);
         }
 
-        unsafe fn append_external_imports(
-            import_object: &mut wasmer_runtime::ImportObject,
-            imports: *mut wasmer_import_t,
-            imports_len: libc::c_int,
-        ) -> wasmer_result_t {
-            use std::collections::HashMap;
-            use std::slice;
-
-            /// original code has been takes from `wasmer_instantiate` located at:
-            /// https://github.com/wasmerio/wasmer/blob/master/lib/runtime-c-api/src/instance.rs
-            let imports: &[wasmer_import_t] = slice::from_raw_parts(imports, imports_len as usize);
-            let mut namespaces = HashMap::new();
-
-            for import in imports {
-                let module_name = slice::from_raw_parts(
-                    import.module_name.bytes,
-                    import.module_name.bytes_len as usize,
-                );
-                let module_name = if let Ok(s) = std::str::from_utf8(module_name) {
-                    s
-                } else {
-                    update_last_error(CApiError {
-                        msg: "error converting module name to string".to_string(),
-                    });
-                    return wasmer_result_t::WASMER_ERROR;
-                };
-                let import_name = slice::from_raw_parts(
-                    import.import_name.bytes,
-                    import.import_name.bytes_len as usize,
-                );
-                let import_name = if let Ok(s) = std::str::from_utf8(import_name) {
-                    s
-                } else {
-                    update_last_error(CApiError {
-                        msg: "error converting import_name to string".to_string(),
-                    });
-                    return wasmer_result_t::WASMER_ERROR;
-                };
-
-                let namespace = namespaces.entry(module_name).or_insert_with(Namespace::new);
-
-                let export = match import.tag {
-                    wasmer_import_export_kind::WASM_FUNCTION => {
-                        let func_export = import.value.func as *mut Export;
-                        (&*func_export).clone()
-                    }
-                    _ => unreachable!(),
-                };
-                namespace.insert(import_name, export);
-            }
-
-            for (module_name, namespace) in namespaces.into_iter() {
-                import_object.register(module_name, namespace);
-            }
-
-            wasmer_result_t::WASMER_OK
-        }
-
         fn cast_import_obj_to_ptr(
-            import_obj: wasmer_runtime::ImportObject,
+            import_object: wasmer_runtime::ImportObject,
         ) -> *mut wasmer_import_object_t {
-            let boxed_import_obj = Box::new(import_obj);
+            let boxed_import_obj = Box::new(import_object);
             let import_obj_ptr: *mut _ = Box::into_raw(boxed_import_obj);
 
             import_obj_ptr as *mut _
diff --git a/crates/svm-wasmer-c-api/tests/c_api.rs b/crates/svm-wasmer-c-api/tests/c_api.rs
index c73aa8d29..c039d2150 100644
--- a/crates/svm-wasmer-c-api/tests/c_api.rs
+++ b/crates/svm-wasmer-c-api/tests/c_api.rs
@@ -1,6 +1,5 @@
 extern crate svm_wasmer_c_api;
 
-use svm_wasmer_c_api::import::wasmer_import_object_t;
 use svm_wasmer_c_api::mem_c_api::*;
 
 use std::ffi::c_void;
@@ -9,11 +8,8 @@ use svm_wasmer::*;
 
 use wasmer_runtime_c_api::{
     export::{wasmer_import_export_kind, wasmer_import_export_value},
-    import::{wasmer_import_func_t, wasmer_import_t},
-    instance::{
-        wasmer_instance_call, wasmer_instance_context_get, wasmer_instance_context_t,
-        wasmer_instance_t,
-    },
+    import::{wasmer_import_func_t, wasmer_import_object_t, wasmer_import_t},
+    instance::{wasmer_instance_context_t, wasmer_instance_t, wasmer_module_import_instantiate},
     module::wasmer_module_t,
     wasmer_byte_array, wasmer_result_t,
 };
@@ -117,19 +113,17 @@ fn node_data_as_ptr(node_data: &NodeData) -> *const c_void {
 }
 
 macro_rules! cast_vmcall_to_import_func_t {
-    ($func: path, $params: expr, $returns: expr) => {
-        unsafe {
-            use std::sync::Arc;
+    ($func: path, $params: expr, $returns: expr) => {{
+        use std::sync::Arc;
 
-            let export = Box::new(Export::Function {
-                func: FuncPointer::new($func as _),
-                ctx: Context::Internal,
-                signature: Arc::new(FuncSig::new($params, $returns)),
-            });
+        let export = Box::new(Export::Function {
+            func: FuncPointer::new($func as _),
+            ctx: Context::Internal,
+            signature: Arc::new(FuncSig::new($params, $returns)),
+        });
 
-            Box::into_raw(export) as *const wasmer_import_func_t
-        }
-    };
+        Box::into_raw(export) as *const wasmer_import_func_t
+    }};
 }
 
 macro_rules! wasmer_compile_module {
@@ -140,19 +134,17 @@ macro_rules! wasmer_compile_module {
         let wasm_bytes_len = wasm.len() as u32;
         let module_ptr_ptr = alloc_module_ptr_ptr();
 
-        unsafe {
-            let compile_res: wasmer_result_t = wasmer_runtime_c_api::module::wasmer_compile(
-                module_ptr_ptr,
-                wasm_bytes,
-                wasm_bytes_len,
-            );
+        let compile_res: wasmer_result_t = wasmer_runtime_c_api::module::wasmer_compile(
+            module_ptr_ptr,
+            wasm_bytes,
+            wasm_bytes_len,
+        );
 
-            // TODO: assert `compile_res` is OK`
-            // assert_eq!(wasmer_result_t::WASMER_OK, compile_res);
+        // TODO: assert `compile_res` is OK`
+        // assert_eq!(wasmer_result_t::WASMER_OK, compile_res);
 
-            let module_ptr: *const wasmer_module_t = *module_ptr_ptr as *const _;
-            module_ptr
-        }
+        let module_ptr: *const wasmer_module_t = *module_ptr_ptr as *const _;
+        module_ptr
     }};
 }
 
@@ -192,26 +184,24 @@ fn alloc_module_ptr_ptr() -> *mut *mut wasmer_module_t {
     alloc_ptr_ptr!(wasmer_module_t)
 }
 
-fn alloc_instance_ptr_ptr() -> *mut *mut wasmer_instance_t {
+fn alloc_raw_instance() -> *mut *mut wasmer_instance_t {
     alloc_ptr_ptr!(wasmer_instance_t)
 }
 
-fn alloc_import_obj_ptr_ptr() -> *mut *mut wasmer_import_object_t {
+fn alloc_raw_import_object() -> *mut *mut wasmer_import_object_t {
     alloc_ptr_ptr!(wasmer_import_object_t)
 }
 
 macro_rules! deref_import_obj {
-    ($import_obj_ptr_ptr: expr) => {{
-        unsafe {
-            let import_obj: &mut ImportObject = &mut *(*$import_obj_ptr_ptr as *mut _);
-            import_obj as *const ImportObject as *const wasmer_import_object_t
-        }
+    ($raw_import_object: expr) => {{
+        let import_obj: &mut ImportObject = &mut *(*$raw_import_object as *mut _);
+        import_obj as *const ImportObject as *const wasmer_import_object_t
     }};
 }
 
 macro_rules! deref_instance {
-    ($instance_ptr_ptr: expr) => {{
-        unsafe { &mut *(*$instance_ptr_ptr as *mut _) }
+    ($raw_instance: expr) => {{
+        &mut *(*$raw_instance as *mut _)
     }};
 }
 
@@ -225,12 +215,11 @@ fn cast_string_to_wasmer_by_array() {
 
 #[test]
 fn call_storage_mem_to_reg_copy() {
-    let node_data = NodeData::default();
-    let import_obj_ptr_ptr = alloc_import_obj_ptr_ptr();
-
     unsafe {
+        let node_data = NodeData::default();
+        let raw_import_object = alloc_raw_import_object();
         wasmer_svm_import_object(
-            import_obj_ptr_ptr,
+            raw_import_object,
             u32_addr_as_ptr(0x11_22_33_44), // `addr_ptr: *const u8`
             5,                              // `max_pages: libc::c_int`
             100,                            // `max_pages_slices: libc::c_int`
@@ -238,39 +227,36 @@ fn call_storage_mem_to_reg_copy() {
             std::ptr::null_mut(),           // `imports: *mut wasmer_import_t`
             0,                              // `imports_len: libc::c_int`
         );
-    };
 
-    let import_object = deref_import_obj!(import_obj_ptr_ptr);
-    let instance_ptr_ptr = alloc_instance_ptr_ptr();
-    let module = wasmer_compile_module_file!("wasm/mem_to_reg_copy.wast");
+        let import_object = deref_import_obj!(raw_import_object);
+        let raw_instance = alloc_raw_instance();
+        let module = wasmer_compile_module_file!("wasm/mem_to_reg_copy.wast");
 
-    unsafe {
-        let res = wasmer_svm_module_instantiate(instance_ptr_ptr, module, import_object);
-    }
-
-    let instance: &Instance = deref_instance!(instance_ptr_ptr);
+        let res = wasmer_module_import_instantiate(raw_instance, module, import_object);
+        let instance: &Instance = deref_instance!(raw_instance);
 
-    // initializing memory #0 cells `200..203` with values `10, 20, 30` respectively
-    wasmer_ctx_mem_cells_write!(instance.context(), 0, 200, &[10, 20, 30]);
+        // initializing memory #0 cells `200..203` with values `10, 20, 30` respectively
+        wasmer_ctx_mem_cells_write!(instance.context(), 0, 200, &[10, 20, 30]);
 
-    let func: Func<(i32, i32, i32)> = instance.func("do_copy_to_reg").unwrap();
-    assert!(func.call(200, 3, 2).is_ok());
+        let func: Func<(i32, i32, i32)> = instance.func("do_copy_to_reg").unwrap();
+        assert!(func.call(200, 3, 2).is_ok());
 
-    // asserting register `2` content is `10, 20, 30, 0, ... 0`
-    let reg = wasmer_ctx_reg!(instance.context(), 2, MemPageCache32);
-    assert_eq!([10, 20, 30, 0, 0, 0, 0, 0], reg.view());
+        // asserting register `2` content is `10, 20, 30, 0, ... 0`
+        let reg = wasmer_ctx_reg!(instance.context(), 2, MemPageCache32);
+        assert_eq!([10, 20, 30, 0, 0, 0, 0, 0], reg.view());
+    }
 }
 
 #[test]
 fn call_node_get_balance() {
-    let node_data = NodeData::default();
-    let gb_ptr = cast_vmcall_to_import_func_t!(get_balance, vec![Type::I32], vec![Type::I64]);
-    let mut gb_import = build_wasmer_import_t("node", "get_balance", gb_ptr);
-    let import_obj_ptr_ptr = alloc_import_obj_ptr_ptr();
-
     unsafe {
+        let node_data = NodeData::default();
+        let gb_ptr = cast_vmcall_to_import_func_t!(get_balance, vec![Type::I32], vec![Type::I64]);
+        let mut gb_import = build_wasmer_import_t("node", "get_balance", gb_ptr);
+        let raw_import_object = alloc_raw_import_object();
+
         wasmer_svm_import_object(
-            import_obj_ptr_ptr,
+            raw_import_object,
             u32_addr_as_ptr(0x11_22_33_44), // `addr_ptr: *const u8`
             5,                              // `max_pages: libc::c_int`
             100,                            // `max_pages_slices: libc::c_int`
@@ -278,33 +264,30 @@ fn call_node_get_balance() {
             &mut gb_import as *mut _,       // `imports: *mut wasmer_import_t`
             1,                              // `imports_len: libc::c_int`
         );
-    };
 
-    let import_object = deref_import_obj!(import_obj_ptr_ptr);
-    let instance_ptr_ptr = alloc_instance_ptr_ptr();
-    let module = wasmer_compile_module_file!("wasm/get_balance.wast");
+        let import_object = deref_import_obj!(raw_import_object);
+        let raw_instance = alloc_raw_instance();
+        let module = wasmer_compile_module_file!("wasm/get_balance.wast");
+        let res = wasmer_module_import_instantiate(raw_instance, module, import_object);
+        let instance: &Instance = deref_instance!(raw_instance);
 
-    unsafe {
-        let res = wasmer_svm_module_instantiate(instance_ptr_ptr, module, import_object);
+        let func: Func<i32, i64> = instance.func("get_balance_proxy").unwrap();
+        let res = func.call(20).unwrap();
+        assert_eq!(100 + 20, res);
     }
-
-    let instance: &Instance = deref_instance!(instance_ptr_ptr);
-    let func: Func<i32, i64> = instance.func("get_balance_proxy").unwrap();
-    let res = func.call(20).unwrap();
-    assert_eq!(100 + 20, res);
 }
 
 #[test]
 fn call_wasmer_svm_instance_context_node_data_get() {
-    let node_data = NodeData::default();
-    let set_ip_ptr = cast_vmcall_to_import_func_t!(set_ip, vec![Type::I32], vec![]);
-    let mut set_ip_import = build_wasmer_import_t("node", "set_ip", set_ip_ptr);
+    unsafe {
+        let node_data = NodeData::default();
+        let set_ip_ptr = cast_vmcall_to_import_func_t!(set_ip, vec![Type::I32], vec![]);
+        let mut set_ip_import = build_wasmer_import_t("node", "set_ip", set_ip_ptr);
 
-    let import_obj_ptr_ptr = alloc_import_obj_ptr_ptr();
+        let raw_import_object = alloc_raw_import_object();
 
-    unsafe {
         wasmer_svm_import_object(
-            import_obj_ptr_ptr,
+            raw_import_object,
             u32_addr_as_ptr(0x11_22_33_44), // `addr_ptr: *const u8`
             5,                              // `max_pages: libc::c_int`
             100,                            // `max_pages_slices: libc::c_int`
@@ -312,37 +295,34 @@ fn call_wasmer_svm_instance_context_node_data_get() {
             &mut set_ip_import as *mut _,   // `imports: *mut wasmer_import_t`
             1,                              // `imports_len: libc::c_int`
         );
-    };
 
-    let import_object = deref_import_obj!(import_obj_ptr_ptr);
-    let instance_ptr_ptr = alloc_instance_ptr_ptr();
-    let module = wasmer_compile_module_file!("wasm/set_ip.wast");
-
-    unsafe {
-        let res = wasmer_svm_module_instantiate(instance_ptr_ptr, module, import_object);
-    }
+        let import_object = deref_import_obj!(raw_import_object);
+        let raw_instance = alloc_raw_instance();
+        let module = wasmer_compile_module_file!("wasm/set_ip.wast");
 
-    let instance: &Instance = deref_instance!(instance_ptr_ptr);
-    let func: Func<i32> = instance.func("set_ip_proxy").unwrap();
+        let res = wasmer_module_import_instantiate(raw_instance, module, import_object);
+        let instance: &Instance = deref_instance!(raw_instance);
+        let func: Func<i32> = instance.func("set_ip_proxy").unwrap();
 
-    assert_eq!([0, 0, 0, 0], node_data.ip);
-    let _ = func.call(0x10_20_30_40).unwrap();
-    assert_eq!([0x10, 0x20, 0x30, 0x40], node_data.ip);
+        assert_eq!([0, 0, 0, 0], node_data.ip);
+        let _ = func.call(0x10_20_30_40).unwrap();
+        assert_eq!([0x10, 0x20, 0x30, 0x40], node_data.ip);
+    }
 }
 
 #[test]
 fn call_wasmer_svm_register_get_set() {
-    let copy_reg2reg_ptr =
-        cast_vmcall_to_import_func_t!(copy_reg_to_reg, vec![Type::I32, Type::I32], vec![]);
+    unsafe {
+        let copy_reg2reg_ptr =
+            cast_vmcall_to_import_func_t!(copy_reg_to_reg, vec![Type::I32, Type::I32], vec![]);
 
-    let mut copy_reg2reg_import =
-        build_wasmer_import_t("node", "copy_reg_to_reg", copy_reg2reg_ptr);
+        let mut copy_reg2reg_import =
+            build_wasmer_import_t("node", "copy_reg_to_reg", copy_reg2reg_ptr);
 
-    let import_obj_ptr_ptr = alloc_import_obj_ptr_ptr();
+        let raw_import_object = alloc_raw_import_object();
 
-    unsafe {
         wasmer_svm_import_object(
-            import_obj_ptr_ptr,
+            raw_import_object,
             u32_addr_as_ptr(0x11_22_33_44), // `addr_ptr: *const u8`
             5,                              // `max_pages: libc::c_int`
             100,                            // `max_pages_slices: libc::c_int`
@@ -350,29 +330,27 @@ fn call_wasmer_svm_register_get_set() {
             &mut copy_reg2reg_import as *mut _, // `imports: *mut wasmer_import_t`
             1,                              // `imports_len: libc::c_int`
         );
-    };
 
-    let import_object = deref_import_obj!(import_obj_ptr_ptr);
-    let instance_ptr_ptr = alloc_instance_ptr_ptr();
-    let module = wasmer_compile_module_file!("wasm/copy_reg_to_reg.wast");
+        let import_object = deref_import_obj!(raw_import_object);
+        let raw_instance = alloc_raw_instance();
+        let module = wasmer_compile_module_file!("wasm/copy_reg_to_reg.wast");
 
-    unsafe {
-        let res = wasmer_svm_module_instantiate(instance_ptr_ptr, module, import_object);
-    }
+        let res = wasmer_module_import_instantiate(raw_instance, module, import_object);
+        let instance: &Instance = deref_instance!(raw_instance);
+        let func: Func<(i32, i32)> = instance.func("copy_reg_to_reg_proxy").unwrap();
 
-    let instance: &Instance = deref_instance!(instance_ptr_ptr);
-    let func: Func<(i32, i32)> = instance.func("copy_reg_to_reg_proxy").unwrap();
+        let ctx = instance.context() as *const Ctx as *const wasmer_instance_context_t;
+        let reg2 = wasmer_svm_register_get(ctx, 2);
+        let reg3 = wasmer_ctx_reg!(instance.context(), 3, MemPageCache32);
 
-    let ctx = instance.context() as *const Ctx as *const wasmer_instance_context_t;
-    let reg2 = unsafe { wasmer_svm_register_get(ctx, 2) };
-    let reg3 = wasmer_ctx_reg!(instance.context(), 3, MemPageCache32);
+        //setting register `2` with data that will be copied later to register `3`
+        wasmer_svm_register_set(ctx, 2, [10, 20, 30, 40, 50, 60, 70, 80].as_ptr(), 8);
 
-    //setting register `2` with data that will be copied later to register `3`
-    unsafe { wasmer_svm_register_set(ctx, 2, [10, 20, 30, 40, 50, 60, 70, 80].as_ptr(), 8) };
-    assert_eq!([0; 8], reg3.view());
+        assert_eq!([0; 8], reg3.view());
 
-    // should trigger copying the contents of register `2` to register `3`
-    let _ = func.call(2, 3).unwrap();
+        // should trigger copying the contents of register `2` to register `3`
+        let _ = func.call(2, 3).unwrap();
 
-    assert_eq!([10, 20, 30, 40, 50, 60, 70, 80], reg3.view());
+        assert_eq!([10, 20, 30, 40, 50, 60, 70, 80], reg3.view());
+    }
 }