Clippy stuff

utxo/src/amount.rs

@@ -82,7 +82,7 @@ impl Amount {
             (human_amount, "".to_owned())
         };
 
-        let fractional_part = fractional_part + &"0".repeat(asset.precision.into());
+        let fractional_part = format!("{}{}", fractional_part, "0".repeat(asset.precision.into()));
 
         let cents = (whole.to_owned() + &fractional_part[..asset.precision.into()])
             .parse::<AmountCents>()
@@ -121,12 +121,14 @@ impl ToString for Amount {
     fn to_string(&self) -> String {
         let str = self.cents.abs().to_string();
         let precision: usize = self.asset.precision.into();
+        #[allow(clippy::arithmetic_side_effects)]
         let str = if str.len() < precision + 1 {
             format!("{}{}", "0".repeat(precision - str.len() + 1), str)
         } else {
             str
         };
 
+        #[allow(clippy::arithmetic_side_effects)]
         let (left, right) = str.split_at(str.len() - precision);
         format!(
             "{}{}.{}",

utxo/src/error.rs

@@ -27,4 +27,12 @@ pub enum Error {
     /// The amount is invalid
     #[error("Invalid amount: {0}")]
     InvalidAmount(#[from] amount::Error),
+
+    /// Overflow in math operation
+    #[error("Overflow")]
+    Overflow,
+
+    /// Underflow in math operation
+    #[error("Underflow")]
+    Underflow,
 }

utxo/src/id.rs

@@ -1,11 +1,10 @@
+use crate::PaymentId;
 use serde::{Deserialize, Deserializer, Serialize};
 use sha2::{Digest, Sha256};
 use std::fmt::Display;
 use std::num::ParseIntError;
 use std::str::FromStr;
 
-use crate::PaymentId;
-
 /// Error
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -17,6 +16,7 @@ pub enum Error {
     #[error("Unknown prefix {0}")]
     UnknownPrefix(String),
 
+    /// Invalid payment ID
     #[error("Invalid PaymentId: {0}")]
     InvalidPaymentId(#[from] ParseIntError),
 }

utxo/src/ledger.rs

@@ -1,6 +1,6 @@
 use crate::{
-    storage::Storage, transaction::Type, AccountId, Amount, AssetManager, Error, Payment,
-    PaymentId, Status, Transaction, TransactionId,
+    amount::AmountCents, storage::Storage, transaction::Type, AccountId, Amount, AssetManager,
+    Error, Payment, PaymentId, Status, Transaction, TransactionId,
 };
 use std::{cmp::Ordering, collections::HashMap};
 
@@ -56,12 +56,14 @@ where
         &self,
         payments: Vec<(AccountId, Amount)>,
     ) -> Result<(Option<Transaction>, Vec<Payment>), Error> {
-        let mut to_spend = HashMap::new();
+        let mut to_spend = HashMap::<_, AmountCents>::new();
 
         for (account_id, amount) in payments.into_iter() {
             let id = (account_id, amount.asset().clone());
             if let Some(value) = to_spend.get_mut(&id) {
-                *value += amount.cents();
+                (*value)
+                    .checked_add(amount.cents())
+                    .ok_or(Error::Overflow)?;
             } else {
                 to_spend.insert(id, amount.cents());
             }
@@ -78,7 +80,7 @@ where
                 .await?;
             for payment in iterator.into_iter() {
                 let cents = payment.amount.cents();
-                to_spend_cents -= cents;
+                to_spend_cents = to_spend_cents.checked_sub(cents).ok_or(Error::Underflow)?;
                 payments.push(payment);
                 match to_spend_cents.cmp(&0) {
                     Ordering::Equal => {
@@ -86,23 +88,27 @@ where
                         break;
                     }
                     Ordering::Less => {
-                        // There is a change amount, we need to split the last
-                        // input into two payment_ids into the same accounts in
-                        // a transaction that will settle immediately, otherwise
-                        // the change amount will be unspendable until this
-                        // transaction settles. By doing so the current
-                        // operation will have no change and it can safely take
-                        // its time to settle without making any change amount
-                        // unspendable.
-                        let to_spend_cents = to_spend_cents.abs();
+                        // The last input a greater amount than needed, therefore the last payment
+                        // must be split into two payments.
+                        //
+                        // This function ensures the exact amounts are used, to archieve that an
+                        // internal transaction is executed to split this unspent payment into two
+                        // unspent payments. This internal transaction settles immediately.
+                        //
+                        // The alternative would be to use this whole unspent payment but the it
+                        // will mean the exchange amount will not be spendable until the current
+                        // transaction finalizes.
+                        let required_amount = to_spend_cents.abs();
                         let input = payments
                             .pop()
                             .ok_or(Error::InsufficientBalance(account.clone(), asset.id))?;
 
+                        let change_back =
+                            cents.checked_sub(required_amount).ok_or(Error::Underflow)?;
+
                         change_input.push(input);
-                        change_output
-                            .push((account.clone(), asset.new_amount(cents - to_spend_cents)));
-                        change_output.push((account.clone(), asset.new_amount(to_spend_cents)));
+                        change_output.push((account.clone(), asset.new_amount(change_back)));
+                        change_output.push((account.clone(), asset.new_amount(required_amount)));
 
                         // Go to the next payment
                         break;
@@ -139,6 +145,7 @@ where
             .await?;
 
             for i in 0..total {
+                #[allow(clippy::arithmetic_side_effects)]
                 // Spend the new payment
                 payments.push(split_input.creates()[i * 2].clone());
             }

utxo/src/lua.rs

@@ -19,7 +19,7 @@ impl TryFrom<&luaValue<'_>> for Value {
                 let mut iter = t.clone().pairs::<String, luaValue>().enumerate();
                 let mut is_vector = true;
                 while let Some((id, Ok((k, v)))) = iter.next() {
-                    if Ok(id + 1) != k.parse() {
+                    if id.checked_add(1) != k.parse().ok() {
                         is_vector = false;
                     }
                     map.insert(k, v.as_ref().try_into()?);
@@ -44,6 +44,7 @@ impl TryFrom<&luaValue<'_>> for Value {
     }
 }
 
+/// Implements the Lua Virtual machine support for the ledger database
 pub struct LuaVM<X: Storage + 'static> {
     state: Arc<X>,
     opcodes: Vec<u8>,
@@ -104,7 +105,7 @@ impl<X: Storage + 'static> LuaVM<X> {
         lua.set_app_data((program_name, storage));
 
         let getter = lua.create_function(move |lua, (global, key): (Table, String)| {
-            match global.raw_get::<_, luaValue>(key.clone())?.into() {
+            match global.raw_get::<_, luaValue>(key.clone())? {
                 luaValue::Nil => (),
                 local_value => return Ok(local_value),
             };
@@ -114,6 +115,8 @@ impl<X: Storage + 'static> LuaVM<X> {
                 .clone();
 
             let key = Variable::new(&program_name, &key);
+            // LuaVM does not like being de-scheduled to run async tasks, any async task must
+            // be executed on the same thread
             let value = block_on(async move { storage.get(instance, key).await });
             Self::var_value_to_lua_val(lua, value)
         })?;
@@ -129,6 +132,8 @@ impl<X: Storage + 'static> LuaVM<X> {
                     return global.raw_set(key, value);
                 };
                 let key = Variable::new(&program_name, &key);
+                // LuaVM does not like being de-scheduled to run async tasks, any async task must
+                // be executed on the same thread
                 block_on(async move {
                     storage.set(instance, key, value).await;
                     Ok(())
@@ -181,7 +186,7 @@ impl<X: Storage + 'static> Instance<X> for LuaVM<X> {
             .map_err(|e| Error::Runtime(e.to_string()))?,
         );
 
-        for val in vec![
+        for val in [
             Variable::Accounts,
             Variable::Balances,
             Variable::Transactions,
@@ -208,7 +213,7 @@ impl<X: Storage + 'static> Instance<X> for LuaVM<X> {
             .call(args)
             .map_err(|e| Error::Runtime(e.to_string()))?;
 
-        result.as_ref().try_into().map_err(|e| Error::Runtime(e))
+        result.as_ref().try_into().map_err(Error::Runtime)
     }
 }
 
@@ -231,7 +236,7 @@ mod test {
             end
 
             return update_state()
-        "#,
+            "#,
         )
         .await
         .unwrap();
@@ -243,7 +248,7 @@ mod test {
             storage.clone(),
             r#"
             return set
-        "#,
+            "#,
         )
         .await
         .unwrap();
@@ -254,13 +259,33 @@ mod test {
         let vm = LuaVM::new(
             storage.clone(),
             r#"
-            print(balances["foo"])
-            balances["foo"] = 100
             return balances["foo"]
-        "#,
+            "#,
         )
         .await
         .unwrap();
-        vm.run(0, "test", vec![]).await.unwrap();
+        let v = vm.run(0, "test", vec![]).await.unwrap();
+        assert_eq!(v.as_integer(), Some(1));
+    }
+
+    #[tokio::test]
+    async fn require_not_allowed() {
+        let storage = Arc::new(crate::vm::memory::Storage::default());
+        let vm = LuaVM::new(
+            storage.clone(),
+            r#"
+            require("foo")
+            "#,
+        )
+        .await
+        .unwrap();
+
+        let r = vm.run(0, "test", vec![]).await;
+        assert!(r.is_err());
+        assert!(r
+            .unwrap_err()
+            .to_string()
+            .find("require is not allowed")
+            .is_some());
     }
 }

utxo/src/main.rs

@@ -1,540 +0,0 @@
-use futures::executor::block_on;
-use mlua::{Compiler, Lua, Table, Value};
-use std::{
-    collections::HashMap,
-    hash::Hash,
-    sync::{
-        atomic::{AtomicU16, AtomicUsize, Ordering},
-        Arc,
-    },
-};
-use tokio::{
-    sync::{mpsc, oneshot, Mutex, RwLock},
-    time::{timeout, Duration},
-};
-
-#[async_trait::async_trait]
-pub trait VarStorage: Send + Sync {
-    async fn get(&self, instance: usize, var: Variable) -> VarValue;
-
-    async fn set(&self, instance: usize, var: Variable, value: VarValue);
-
-    async fn shutdown(&self, instance: usize);
-}
-
-type Sender<I, R> = mpsc::Sender<(Vec<I>, oneshot::Sender<R>)>;
-type Receiver<I, R> = mpsc::Receiver<(Vec<I>, oneshot::Sender<R>)>;
-
-#[derive(Debug)]
-pub struct Program<X>
-where
-    X: VarStorage + 'static,
-{
-    opcodes: Vec<u8>,
-    instances: Arc<AtomicUsize>,
-    running: Arc<AtomicU16>,
-    execution_id: Arc<AtomicUsize>,
-    storage: Arc<X>,
-    sender: Sender<VarValue, VarValue>,
-    receiver: Arc<Mutex<Receiver<VarValue, VarValue>>>,
-}
-
-#[derive(Debug, Clone)]
-pub enum VarValue {
-    /// The Lua value `nil`.
-    Nil,
-    /// The Lua value `true` or `false`.
-    Boolean(bool),
-    /// Integer number
-    Integer(i128),
-    /// A floating point number.
-    Number(f64),
-    /// String
-    String(String),
-    /// A vector
-    Vector(Vec<VarValue>),
-    /// A
-    HashMap(HashMap<String, VarValue>),
-    /// An error
-    ErrorType(String),
-}
-
-pub enum Variable {
-    Balances,
-    Accounts,
-    Transactions,
-    Payments,
-    Other(String),
-}
-
-impl From<String> for Variable {
-    fn from(s: String) -> Self {
-        match s.as_str() {
-            "balances" => Self::Balances,
-            "accounts" => Self::Accounts,
-            "transactions" => Self::Transactions,
-            "payments" => Self::Payments,
-            _ => Self::Other(s),
-        }
-    }
-}
-
-impl Variable {
-    pub fn name<'a>(&'a self) -> &'a str {
-        match self {
-            Self::Balances => "balances",
-            Self::Accounts => "accounts",
-            Self::Transactions => "transactions",
-            Self::Payments => "payments",
-            Self::Other(s) => s,
-        }
-    }
-}
-
-impl<X> Program<X>
-where
-    X: VarStorage + 'static,
-{
-    pub fn new(opcodes: Vec<u8>, storage: Arc<X>) -> Program<X> {
-        let (sender, receiver) = mpsc::channel(100);
-        Self {
-            storage,
-            instances: Arc::new(AtomicUsize::new(0)),
-            execution_id: Arc::new(AtomicUsize::new(0)),
-            running: Arc::new(AtomicU16::new(0)),
-            receiver: Arc::new(Mutex::new(receiver)),
-            opcodes,
-            sender,
-        }
-    }
-
-    fn var_value_to_lua_val(lua: &Lua, value: VarValue) -> mlua::Result<Value> {
-        match value {
-            VarValue::Nil => Ok(Value::Nil),
-            VarValue::Boolean(b) => Ok(Value::Boolean(b)),
-            VarValue::Integer(i) => Ok(Value::Integer(i.try_into().unwrap())),
-            VarValue::Number(n) => Ok(Value::Number(n)),
-            VarValue::String(s) => Ok(Value::String(lua.create_string(&s)?)),
-            VarValue::HashMap(map) => {
-                let table = lua.create_table()?;
-                for (k, v) in map {
-                    table.set(k, Self::var_value_to_lua_val(lua, v)?)?;
-                }
-                Ok(Value::Table(table))
-            }
-            VarValue::ErrorType(e) => Err(mlua::Error::RuntimeError(e.to_string())),
-            _ => Err(mlua::Error::RuntimeError("Invalid type".into())),
-        }
-    }
-
-    fn inject_dynamic_global_state(
-        lua: &Lua,
-        storage: Arc<X>,
-        instance: usize,
-    ) -> mlua::Result<Option<Table>> {
-        lua.set_app_data(storage);
-
-        let getter = lua.create_function(move |lua, (global, key): (Table, String)| {
-            match global.raw_get::<_, Value>(key.clone())?.into() {
-                Value::Nil => (),
-                local_value => return Ok(local_value),
-            };
-            let storage = lua
-                .app_data_ref::<Arc<X>>()
-                .ok_or(mlua::Error::MismatchedRegistryKey)?
-                .clone();
-            let value = block_on(async move { storage.get(instance, key.into()).await });
-            Self::var_value_to_lua_val(lua, value)
-        })?;
-        let setter =
-            lua.create_function(move |lua, (global, key, value): (Table, String, Value)| {
-                let storage = lua
-                    .app_data_ref::<Arc<X>>()
-                    .ok_or(mlua::Error::MismatchedRegistryKey)?
-                    .clone();
-                let value: VarValue = if let Ok(value) = value.as_ref().try_into() {
-                    value
-                } else {
-                    return global.raw_set(key, value);
-                };
-                block_on(async move {
-                    storage.set(instance, key.into(), value).await;
-                    Ok(())
-                })
-            })?;
-
-        let metatable = lua.create_table()?;
-        metatable.raw_set("__index", getter)?;
-        metatable.raw_set("__newindex", setter)?;
-
-        Ok(Some(metatable))
-    }
-
-    /// Returns a new Lua VM and a list of all the global variables to be
-    /// persisted and read from the storage engine. Since lua is a dynamic
-    /// language, other state variables may be read/updated dynamically, which
-    /// is fine, this list is just for the initial state and any potential
-    /// optimization.
-    fn execute_program(state: Arc<X>, instance: usize, bytecode: &[u8]) -> mlua::Result<VarValue> {
-        let lua = Lua::new();
-        let globals = lua.globals();
-
-        let require = lua.create_function(|_, (_,): (String,)| -> mlua::Result<()> {
-            Err(mlua::Error::RuntimeError("require is not allowed".into()))
-        })?;
-
-        globals.set_metatable(Self::inject_dynamic_global_state(
-            &lua,
-            state.clone(),
-            instance,
-        )?);
-        lua.set_memory_limit(100 * 1024 * 1024)?;
-
-        // remove external require
-        globals.set("require", require)?;
-        drop(globals);
-
-        // load main program
-        let x: Value = lua.load(bytecode).call(())?;
-
-        // shutdown the execution and let the storage / state engine know so all
-        // locked variables by this execution_id can be released
-        block_on(async move {
-            state.shutdown(instance).await;
-        });
-
-        x.as_ref().try_into().map_err(|_| mlua::Error::StackError)
-    }
-
-    fn spawn(
-        storage: Arc<X>,
-        bytecode: Vec<u8>,
-        instances: Arc<AtomicUsize>,
-        exec_id: Arc<AtomicUsize>,
-        running: Arc<AtomicU16>,
-        receiver: Arc<Mutex<Receiver<VarValue, VarValue>>>,
-    ) {
-        if instances.load(Ordering::Relaxed) > 100 {
-            return;
-        }
-
-        instances.fetch_add(1, Ordering::Relaxed);
-        let max_timeout = Duration::from_secs(30);
-
-        tokio::task::spawn_blocking(move || {
-            loop {
-                if let Ok(mut queue) =
-                    futures::executor::block_on(timeout(max_timeout, receiver.lock()))
-                {
-                    if let Ok(Some((_inputs, output))) =
-                        futures::executor::block_on(timeout(max_timeout, queue.recv()))
-                    {
-                        let exec_id: usize = exec_id.fetch_add(1, Ordering::Relaxed);
-                        // drop queue lock to release the mutex so any other
-                        // free VM can use it to listen for incoming messages
-                        drop(queue);
-
-                        let ret =
-                            Self::execute_program(storage.clone(), exec_id, &bytecode).unwrap();
-
-                        running.fetch_add(1, Ordering::Relaxed);
-                        let _ = output.send(ret).unwrap();
-                        continue;
-                    }
-                }
-                break;
-            }
-
-            println!("Lua listener is exiting");
-            instances.fetch_sub(1, Ordering::Relaxed);
-        });
-    }
-
-    pub async fn exec(&self, input: Vec<VarValue>) -> VarValue {
-        let (return_notifier, return_listener) = oneshot::channel();
-        Self::spawn(
-            self.storage.clone(),
-            self.opcodes.clone(),
-            self.instances.clone(),
-            self.execution_id.clone(),
-            self.running.clone(),
-            self.receiver.clone(),
-        );
-        self.sender
-            .send((input, return_notifier))
-            .await
-            .expect("valid");
-        return_listener.await.expect("valid")
-    }
-}
-
-impl TryFrom<&Value<'_>> for VarValue {
-    type Error = String;
-
-    fn try_from(value: &Value<'_>) -> Result<Self, Self::Error> {
-        match value {
-            Value::Nil => Ok(VarValue::Nil),
-            Value::Boolean(b) => Ok(VarValue::Boolean(*b)),
-            Value::Integer(i) => Ok(VarValue::Integer((*i).into())),
-            Value::Number(n) => Ok(VarValue::Number(*n)),
-            Value::String(s) => Ok(VarValue::String(s.to_str().unwrap().to_owned())),
-            Value::Table(t) => {
-                let mut map = HashMap::new();
-                let mut iter = t.clone().pairs::<String, Value>().enumerate();
-                let mut is_vector = true;
-                while let Some((id, Ok((k, v)))) = iter.next() {
-                    if Ok(id + 1) != k.parse() {
-                        is_vector = false;
-                    }
-                    map.insert(k, v.as_ref().try_into()?);
-                }
-
-                Ok(if is_vector {
-                    let mut values = map
-                        .into_iter()
-                        .map(|(k, v)| k.parse().map(|k| (k, v)))
-                        .collect::<Result<Vec<(usize, VarValue)>, _>>()
-                        .unwrap();
-
-                    values.sort_by(|(a, _), (b, _)| a.cmp(b));
-
-                    VarValue::Vector(values.into_iter().map(|(_, v)| v).collect())
-                } else {
-                    VarValue::HashMap(map)
-                })
-            }
-            x => Err(format!("Invalid type: {:?}", x)),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct VarStorageMem {
-    storage: RwLock<HashMap<String, VarValue>>,
-    locks: RwLock<HashMap<String, usize>>,
-    var_locked_by_instance: Mutex<HashMap<usize, Vec<String>>>,
-}
-
-impl Default for VarStorageMem {
-    fn default() -> Self {
-        Self {
-            storage: RwLock::new(HashMap::new()),
-            locks: RwLock::new(HashMap::new()),
-            var_locked_by_instance: Mutex::new(HashMap::new()),
-        }
-    }
-}
-
-impl VarStorageMem {
-    async fn lock(&self, instance: usize, var: &Variable) {
-        let locks = self.locks.read().await;
-        let name = var.name();
-
-        if locks.get(name).map(|v| *v) == Some(instance) {
-            // The variable is already locked by this instance
-            return;
-        }
-
-        drop(locks);
-
-        loop {
-            // wait here while the locked is not null or it is locked by another
-            // instance
-            let locks = self.locks.read().await;
-            let var_lock = locks.get(name).map(|v| *v);
-            if var_lock.is_none() || var_lock == Some(instance) {
-                break;
-            }
-            drop(locks);
-            tokio::time::sleep(Duration::from_micros(10)).await;
-        }
-
-        loop {
-            let mut locks = self.locks.write().await;
-            let var_lock = locks.get(name).map(|v| *v);
-
-            if !var_lock.is_none() {
-                if var_lock == Some(instance) {
-                    break;
-                }
-                drop(locks);
-                tokio::time::sleep(Duration::from_micros(10)).await;
-                continue;
-            }
-
-            locks.insert(name.to_owned(), instance);
-
-            let mut vars_by_instance = self.var_locked_by_instance.lock().await;
-            if let Some(vars) = vars_by_instance.get_mut(&instance) {
-                vars.push(name.to_owned());
-            } else {
-                vars_by_instance.insert(instance, vec![name.to_owned()]);
-            }
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl VarStorage for VarStorageMem {
-    async fn get(&self, instance: usize, var: Variable) -> VarValue {
-        self.lock(instance, &var).await;
-        self.storage
-            .read()
-            .await
-            .get(var.name())
-            .cloned()
-            .unwrap_or(VarValue::Nil)
-    }
-
-    async fn set(&self, instance: usize, var: Variable, value: VarValue) {
-        self.lock(instance, &var).await;
-        self.storage
-            .write()
-            .await
-            .insert(var.name().to_owned(), value);
-    }
-
-    async fn shutdown(&self, instance: usize) {
-        let mut vars_by_instance = self.var_locked_by_instance.lock().await;
-        let mut locks = self.locks.write().await;
-
-        if let Some(vars) = vars_by_instance.remove(&instance) {
-            for var in vars {
-                if locks.get(&var).map(|v| *v) == Some(instance) {
-                    locks.remove(&var);
-                }
-            }
-        }
-    }
-}
-
-pub struct Runtime<K: Hash + Eq, X: VarStorage + 'static> {
-    vms: RwLock<HashMap<K, Program<X>>>,
-}
-
-impl<K: Hash + Eq, X: VarStorage + 'static> Runtime<K, X> {
-    pub fn new() -> Arc<Self> {
-        Arc::new(Self {
-            vms: RwLock::new(HashMap::new()),
-        })
-    }
-
-    pub async fn register_program(&self, name: K, program: &str, storage: Arc<X>) -> bool {
-        self.register_opcodes(name, Compiler::new().compile(program), storage)
-            .await
-    }
-
-    pub async fn exec(&self, id: &K) -> Option<VarValue> {
-        if let Some(vm) = self.vms.read().await.get(id) {
-            Some(vm.exec(vec![VarValue::Integer(1)]).await)
-        } else {
-            None
-        }
-    }
-
-    pub async fn register_opcodes(&self, name: K, opcodes: Vec<u8>, storage: Arc<X>) -> bool {
-        let mut vms = self.vms.write().await;
-
-        vms.insert(name, Program::new(opcodes, storage)).is_some()
-    }
-
-    pub async fn shutdown(&self) {
-        let mut vms = self.vms.write().await;
-        vms.clear();
-    }
-}
-
-#[tokio::main]
-async fn main() {
-    use std::{sync::Arc, time::Instant};
-
-    let mem = Arc::new(VarStorageMem::default());
-
-    async fn do_loop(vms: Arc<Runtime<String, VarStorageMem>>) {
-        // Create N threads to execute the Lua code in parallel
-        let num_threads = 400;
-        let (tx, mut rx) = mpsc::channel(num_threads);
-        for _ in 0..num_threads {
-            let vm = vms.clone();
-            let tx_clone = tx.clone();
-
-            tokio::spawn(async move {
-                let start_time = Instant::now();
-                let result = vm.exec(&"foo".to_owned()).await;
-
-                // Send the result back to the main thread
-                let _ = tx_clone.send(result).await;
-
-                let elapsed_time = Instant::now() - start_time;
-
-                // Print the elapsed time in seconds and milliseconds
-                println!(
-                    "Elapsed time: {} seconds {} milliseconds",
-                    elapsed_time.as_secs(),
-                    elapsed_time.as_millis(),
-                );
-            });
-        }
-
-        drop(tx);
-
-        loop {
-            let result = rx.recv().await;
-            if result.is_none() {
-                break;
-            }
-            println!("Result: {:?}", result.unwrap());
-        }
-    }
-
-    let vms = Runtime::new();
-
-    // Compile Lua code
-    let _code = r#"
-        function add(a, b)
-            calls = calls + 1
-            print("Call from old " .. pid .. " "  .. calls)
-            return a + b
-        end
-        print("hello world " .. pid)
-    "#;
-    let code = r#"
-        if pid == nil then
-            pid = 0
-        end
-        pid = pid + 1
-        print("hello world " .. pid)
-        return true
-    "#;
-
-    let _ = vms
-        .register_program("foo".to_owned(), code, mem.clone())
-        .await;
-    do_loop(vms.clone()).await;
-
-    let code = r#"
-        if pid == nil then
-            pid = 0
-        end
-        pid = pid + 1
-        function add(a, b)
-            foo = {1,"foo"}
-            print("Call from new " .. pid .. " ")
-            return a + b
-        end
-        print("hello world " .. pid .. " = " .. add(pid, pid))
-        return false
-    "#;
-    let y = vms
-        .register_program("foo".to_owned(), code, mem.clone())
-        .await;
-    tokio::time::sleep(Duration::from_secs(3)).await;
-
-    do_loop(vms.clone()).await;
-
-    vms.shutdown().await;
-
-    tokio::time::sleep(Duration::from_secs(1)).await;
-
-    println!("{} {:?}", "foo", mem);
-}

utxo/src/vm/state/mod.rs

@@ -50,7 +50,7 @@ impl Value {
     pub fn is_hashmap(&self) -> bool {
         match self {
             Self::HashMap(_) | Self::DynamicHashMap(_) => true,
-            Self::Vector(x) => x.len() == 0,
+            Self::Vector(x) => x.is_empty(),
             _ => false,
         }
     }