update smoldot (#617)

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "vendor/smoldot"]
 	path = vendor/smoldot
-	url = https://github.com/ermalkaleci/smoldot.git
+	url = https://github.com/smol-dot/smoldot.git

executor/src/proof.rs

@@ -21,9 +21,6 @@ pub fn decode_proof(
     let entries = decoded
         .iter_ordered()
         .filter(|(key, entry)| {
-            if key.key.is_empty() {
-                return false;
-            }
             if !key.trie_root_hash.eq(&trie_root_hash.0) {
                 return false;
             }
@@ -33,9 +30,7 @@ pub fn decode_proof(
             )
         })
         .map(|(key, entry)| {
-            let key = HexString(
-                nibbles_to_bytes_suffix_extend(key.key.iter().cloned()).collect::<Vec<_>>(),
-            );
+            let key = HexString(nibbles_to_bytes_suffix_extend(key.key).collect::<Vec<_>>());
             match entry.trie_node_info.storage_value {
                 StorageValue::Known { value, .. } => (key, HexString(value.to_vec())),
                 _ => unreachable!(),
@@ -75,9 +70,7 @@ pub fn create_proof(
     for (entry_key, value) in decoded.iter_ordered() {
         let decoded_value = trie_node::decode(value.node_value).unwrap();
 
-        if let trie_structure::Entry::Vacant(vacant) =
-            trie.node(entry_key.key.iter().map(|x| x.to_owned()))
-        {
+        if let trie_structure::Entry::Vacant(vacant) = trie.node(entry_key.key) {
             if let trie_node::StorageValue::Unhashed(value) = decoded_value.storage_value {
                 vacant.insert_storage_value().insert(value.to_vec(), vec![]);
             }

executor/src/task.rs

@@ -3,8 +3,8 @@ use serde::{Deserialize, Serialize};
 use serde_wasm_bindgen::{from_value, to_value};
 use smoldot::{
     executor::{
-        host::{Config, HeapPages, HostVmPrototype},
-        runtime_host::{self, OffchainContext, RuntimeHostVm},
+        host::{Config, HeapPages, HostVmPrototype, LogEmitInfo},
+        runtime_call::{self, OffchainContext, RuntimeCall},
         storage_diff::TrieDiff,
         CoreVersionRef,
     },
@@ -14,7 +14,6 @@ use smoldot::{
         calculate_root::{root_merkle_value, RootMerkleValueCalculation},
         nibbles_to_bytes_suffix_extend, HashFunction, TrieEntryVersion,
     },
-    verify::body_only::LogEmitInfo,
 };
 use std::collections::BTreeMap;
 use wasm_bindgen::prelude::*;
@@ -134,7 +133,7 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
     let mut runtime_logs: Vec<LogInfo> = vec![];
 
     for (call, params) in task.calls {
-        let mut vm = runtime_host::run(runtime_host::Config {
+        let mut vm = runtime_call::run(runtime_call::Config {
             virtual_machine: vm_proto.clone(),
             function_to_call: call.as_str(),
             parameter: params.into_iter().map(|x| x.0),
@@ -148,11 +147,11 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
 
         let res = loop {
             vm = match vm {
-                RuntimeHostVm::Finished(res) => {
+                RuntimeCall::Finished(res) => {
                     break res;
                 }
 
-                RuntimeHostVm::StorageGet(req) => {
+                RuntimeCall::StorageGet(req) => {
                     let key = if let Some(child) = req.child_trie() {
                         HexString(prefixed_child_key(
                             child.as_ref().iter().copied(),
@@ -184,13 +183,13 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
                     }
                 }
 
-                RuntimeHostVm::ClosestDescendantMerkleValue(req) => {
+                RuntimeCall::ClosestDescendantMerkleValue(req) => {
                     let value = js.get_state_root().await?;
                     let value = from_value::<HexString>(value).map(|x| x.0)?;
                     req.inject_merkle_value(Some(value.as_ref()))
                 }
 
-                RuntimeHostVm::NextKey(req) => {
+                RuntimeCall::NextKey(req) => {
                     if req.branch_nodes() {
                         // root_calculation, skip
                         req.inject_key(None::<Vec<_>>.map(|x| x.into_iter()))
@@ -222,7 +221,7 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
                     }
                 }
 
-                RuntimeHostVm::SignatureVerification(req) => {
+                RuntimeCall::SignatureVerification(req) => {
                     let bypass =
                         task.mock_signature_host && is_magic_signature(req.signature().as_ref());
                     if bypass {
@@ -232,15 +231,15 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
                     }
                 }
 
-                RuntimeHostVm::OffchainStorageSet(req) => {
+                RuntimeCall::OffchainStorageSet(req) => {
                     offchain_storage_changes.insert(
                         req.key().as_ref().to_vec(),
                         req.value().map(|x| x.as_ref().to_vec()),
                     );
                     req.resume()
                 }
 
-                RuntimeHostVm::Offchain(ctx) => match ctx {
+                RuntimeCall::Offchain(ctx) => match ctx {
                     OffchainContext::StorageGet(req) => {
                         let key = HexString(req.key().as_ref().to_vec());
                         let key = to_value(&key)?;
@@ -292,7 +291,7 @@ pub async fn run_task(task: TaskCall, js: crate::JsCallback) -> Result<TaskRespo
                     }
                 },
 
-                RuntimeHostVm::LogEmit(req) => {
+                RuntimeCall::LogEmit(req) => {
                     {
                         match req.info() {
                             LogEmitInfo::Num(v) => {