Cargo.lock

@@ -1,6 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-# SPDX-License-Identifier: Apache-2.0
 version = 4
 
 [[package]]
@@ -1183,7 +1184,7 @@ dependencies = [
 [[package]]
 name = "detee-shared"
 version = "0.1.0"
-source = "git+ssh://git@gitea.detee.cloud/testnet/proto.git?branch=credits_app#01e93d3a2e4502c0e8e72026e8a1c55810961815"
+source = "git+ssh://git@gitea.detee.cloud/testnet/proto.git?branch=surreal_brain_app#0b195b4589e4ec689af7ddca27dc051716ecee78"
 dependencies = [
  "bincode",
  "prost",

Cargo.toml

@@ -36,7 +36,7 @@ tokio-retry = "0.3.0"
 detee-sgx = { git = "ssh://git@gitea.detee.cloud/testnet/detee-sgx.git", branch = "hratls", features=["hratls", "qvl"] }
 shadow-rs = { version = "1.1.1", features = ["metadata"] }
 
-detee-shared = { git = "ssh://git@gitea.detee.cloud/testnet/proto.git", branch = "credits_app" }
+detee-shared = { git = "ssh://git@gitea.detee.cloud/testnet/proto.git", branch = "surreal_brain_app" }
 # detee-shared = { path = "../detee-shared" }
 
 [build-dependencies]

rustfmt.toml

@@ -2,4 +2,4 @@
 
 reorder_impl_items = true
 use_small_heuristics = "Max"
-imports_granularity = "Module"
+imports_granularity = "Crate"

samples/new_vm/advanced_os_config.yaml

@@ -11,8 +11,8 @@ ipv4: !PublishPorts
 # ipv4: !PublishPorts [ 80, 8080 ]
 public_ipv6: false
 vcpus: 2
-memory_gib: 2000
-disk_size_gib: 20
+memory_mb: 2000
+disk_size_gb: 20
 # os_setup is an optional field that allows you to specify the operating system
 # dtrfs is the DeTEE initramfs required to boot a VM. It also needs a kernel.
 # The OS Template is normally a Linux distribution (without initrd and kernel)

samples/new_vm/no_public_ips.yaml

@@ -11,5 +11,5 @@ ipv4: !PublishPorts
 # ipv4: !PublishPorts [ 80, 8080 ]
 public_ipv6: false
 vcpus: 2
-memory_gib: 2
-disk_size_gib: 20
+memory_mb: 2000
+disk_size_gb: 20

samples/new_vm/public_ipv4_and_ipv6.yaml

@@ -13,5 +13,5 @@ ipv4: !PublicIPv4
 # For IPv6, just specify true or false if you want a public IP
 public_ipv6: true
 vcpus: 2
-memory_gib: 2
-disk_size_gib: 20
+memory_mb: 2000
+disk_size_gb: 20

samples/new_vm/specific_city.yaml

@@ -12,5 +12,5 @@ location:
 ipv4: !PublicIPv4
 public_ipv6: false
 vcpus: 2
-memory_gib: 1000
-disk_size_gib: 20
+memory_mb: 1000
+disk_size_gb: 20

src/bin/detee-cli.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use clap::builder::PossibleValue;
-use clap::{Arg, Command};
+use clap::{builder::PossibleValue, Arg, Command};
 use detee_cli::general::cli_handler::{
     handle_account, handle_completion, handle_operators, handle_packagers,
 };
@@ -54,16 +53,6 @@ fn main() {
 }
 
 fn clap_cmd() -> Command {
-    let snp_locations = [
-        PossibleValue::new("GB").help("London, England, GB"),
-        PossibleValue::new("Canada").help("Montréal or Vancouver"),
-        PossibleValue::new("Montreal").help("Montréal, Quebec, CA"),
-        PossibleValue::new("Vancouver").help("Vancouver, British Columbia, CA"),
-        PossibleValue::new("California").help("San Jose, California, US"),
-        PossibleValue::new("US").help("San Jose, California, US"),
-        PossibleValue::new("France").help("Paris, Île-de-France, FR"),
-        PossibleValue::new("Any").help("List offers for any location."),
-    ];
     Command::new("detee-cli")
         .version(build::CLAP_LONG_VERSION)
         .author("https://detee.ltd")
@@ -171,13 +160,13 @@ fn clap_cmd() -> Command {
                         .help("for how many hours should the app run")
                         .default_value("1")
                         .value_parser(clap::value_parser!(u64).range(1..5000))
-                        .long_help("How long should the app run for so it locks up credits accordingly")
+                        .long_help("How long should the app run for so it locks up LP accordingly")
                     )
                     .arg(
                         Arg::new("price")
                         .long("price")
-                        .help("maxium accepted price per unit per minute")
-                        .default_value("4000")
+                        .help("price per unit per minute; check docs")
+                        .default_value("200000")
                         .value_parser(clap::value_parser!(u64).range(1..50000000))
                     )
                     .arg(
@@ -336,8 +325,17 @@ fn clap_cmd() -> Command {
                     Arg::new("location")
                     .help("deploy to a specific location")
                     .long("location")
-                    .default_value("Any")
-                    .value_parser(snp_locations.clone()),
+                    .default_value("Vancouver")
+                    .value_parser([
+                        PossibleValue::new("GB").help("London, England, GB"),
+                        PossibleValue::new("Canada").help("Montréal or Vancouver"),
+                        PossibleValue::new("Montreal").help("Montréal, Quebec, CA"),
+                        PossibleValue::new("Vancouver").help("Vancouver, British Columbia, CA"),
+                        PossibleValue::new("California").help("San Jose, California, US"),
+                        PossibleValue::new("US").help("San Jose, California, US"),
+                        PossibleValue::new("France").help("Paris, Île-de-France, FR"),
+                        PossibleValue::new("Random").help("Just deploy somewhere..."),
+                    ]),
                 )
                 .arg(
                     Arg::new("vcpus")
@@ -349,16 +347,16 @@ fn clap_cmd() -> Command {
                 .arg(
                     Arg::new("memory")
                     .long("memory")
-                    .default_value("1")
-                    .value_parser(clap::value_parser!(u32).range(1..500))
-                    .help("memory in GiB")
+                    .default_value("1000")
+                    .value_parser(clap::value_parser!(u32).range(800..123000))
+                    .help("memory in MB")
                 )
                 .arg(
                     Arg::new("disk")
                     .long("disk")
                     .default_value("10")
                     .value_parser(clap::value_parser!(u32).range(5..500))
-                    .help("disk size in GiB")
+                    .help("disk size in GB")
                 )
                 .arg(
                     Arg::new("distribution")
@@ -377,8 +375,8 @@ fn clap_cmd() -> Command {
                 .arg(
                     Arg::new("price")
                     .long("price")
-                    .help("maxium accepted price per unit per minute")
-                    .default_value("4000")
+                    .help("price per unit per minute; check docs")
+                    .default_value("20000")
                     .value_parser(clap::value_parser!(u64).range(1..50000000))
                 )
                 .arg(
@@ -439,7 +437,7 @@ fn clap_cmd() -> Command {
                 .long_about("Allows you to update the hardware or the lifetime".to_string() +
                     "\nAny hardware modifiations will restart the VM." +
                     "\nChanging the lifetime of a VM will not restart." +
-                    "\nIf changing the lifetime to a higher value, credits will locked accordingly.")
+                    "\nIf changing the lifetime to a higher value, LP will locked accordingly.")
                 .arg(
                     Arg::new("uuid")
                     .help("supply the uuid of the VM you wish to upgrade")
@@ -462,15 +460,15 @@ fn clap_cmd() -> Command {
                     Arg::new("memory")
                     .long("memory")
                     .default_value("0")
-                    .value_parser(clap::value_parser!(u32).range(0..5000))
-                    .help("modify the GiB of memory reserved")
+                    .value_parser(clap::value_parser!(u32).range(0..115000))
+                    .help("modify the MB of memory reserved")
                 )
                 .arg(
                     Arg::new("disk")
                     .long("disk")
                     .default_value("0")
                     .value_parser(clap::value_parser!(u32).range(0..500))
-                    .help("increase the size of the disk in GiB")
+                    .help("increase the size of the disk in GB")
                 )
                 .arg(
                     Arg::new("hours")
@@ -503,24 +501,7 @@ fn clap_cmd() -> Command {
         )
         .subcommand(Command::new("vm-node")
             .about("info about AMD SEV-SNP servers registerd to DeTEE")
-            .subcommand(Command::new("search").about("search nodes based on filters")
-                .arg(
-                    Arg::new("location")
-                    .help("deploy to a specific location")
-                    .long("location")
-                    .default_value("Any")
-                    .value_parser(snp_locations.clone()),
-                )
-            )
-            .subcommand(Command::new("offers").about("search nodes based on filters")
-                .arg(
-                    Arg::new("location")
-                    .help("deploy to a specific location")
-                    .long("location")
-                    .default_value("Any")
-                    .value_parser(snp_locations),
-                )
-            )
+            .subcommand(Command::new("search").about("search nodes based on filters"))
             .subcommand(Command::new("inspect").about("get detailed information about a node")
                 .arg(
                     Arg::new("ip")
@@ -556,7 +537,7 @@ fn clap_cmd() -> Command {
                 .arg(
                     Arg::new("escrow")
                     .long("escrow")
-                    .help("At least 5000 credits is required as escrow")
+                    .help("At least 5000 LP is required as escrow")
                     .long_help("Escrow is used by node operators to guarantee quality.".to_owned() +
                         "\nBefore adding escrow, make sure you booted a node under your account." +
                         "\nWhen all your nodes got decomissioned, your escrow gets automatically returned.")

src/config.rs

@@ -1,8 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::constants::{BRAIN_STAGING, BRAIN_TESTING};
-use crate::general;
-use crate::utils::block_on;
+use crate::{general, utils::block_on};
 use ed25519_dalek::SigningKey;
 use log::{debug, info, warn};
 use openssl::bn::BigNum;
@@ -10,9 +9,7 @@ use openssl::hash::{Hasher, MessageDigest};
 use openssl::pkey::{PKey, Private};
 use openssl::rsa::Rsa;
 use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io::Write;
-use std::path::Path;
+use std::{fs::File, io::Write, path::Path};
 
 #[derive(Serialize, Default)]
 pub struct AccountData {
@@ -39,10 +36,10 @@ impl super::HumanOutput for AccountData {
         }
         if !self.wallet_path.is_empty() {
             println!("The address of your DeTEE wallet is {}", self.wallet_address);
-            println!("The balance of your account is {} credits", self.account_balance);
+            println!("The balance of your account is {} LP", self.account_balance);
             if self.locked_funds != 0.0 {
                 println!(
-                    "WARNING! {} credits is temporary locked, waiting for a Contract.",
+                    "WARNING! {} LP is temporary locked, waiting for a Contract.",
                     self.locked_funds
                 );
             }

src/general/cli_handler.rs

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use super::{operators, packagers};
+use super::operators;
+use super::packagers;
 use crate::{cli_print, config};
-use clap::{ArgMatches, Command};
+use clap::ArgMatches;
+use clap::Command;
 use clap_complete::{generate, Shell};
 use std::error::Error;
 use std::io;

src/general/grpc.rs

@@ -96,7 +96,7 @@ pub async fn kick_contract(contract_uuid: String, reason: String) -> Result<u64,
         })?)
         .await?
         .into_inner()
-        .nano_credits)
+        .nano_lp)
 }
 
 pub async fn ban_user(user_wallet: String) -> Result<(), Error> {

src/general/operators.rs

@@ -35,7 +35,7 @@ pub fn register(escrow: u64, email: String) -> Result<crate::SimpleOutput, grpc:
 impl crate::HumanOutput for grpc::proto::InspectOperatorResp {
     fn human_cli_print(&self) {
         if let Some(op) = &self.operator {
-            println!("The operator {} supplies {} nanocredits as escrow,", op.pubkey, op.escrow,);
+            println!("The operator {} supplies {} nanoLP as escrow,", op.pubkey, op.escrow,);
             println!(
                 "has {} app servers, {} VM servers, and {} total reports for all servers.",
                 op.app_nodes, op.vm_nodes, op.reports
@@ -77,7 +77,7 @@ pub fn print_operators() -> Result<Vec<grpc::proto::ListOperatorsResp>, grpc::Er
 pub fn kick(contract_uuid: String, reason: String) -> Result<crate::SimpleOutput, grpc::Error> {
     let nano_lp = block_on(grpc::kick_contract(contract_uuid, reason))?;
     Ok(crate::SimpleOutput::from(
-        format!("Successfully terminated contract. Refunded {} nanocredits.", nano_lp).as_str(),
+        format!("Successfully terminated contract. Refunded {} nanoLP.", nano_lp).as_str(),
     ))
 }
 

src/name_generator.rs

@@ -380,3 +380,4 @@ const APP_SUBSTANTIVES: [&str; 70] = [
     "gecko",
     "zebra",
 ];
+

src/sgx/cli_handler.rs

@@ -9,16 +9,18 @@ use crate::sgx::packaging::package_enclave;
 use crate::sgx::utils::{
     deploy_new_app_and_update_config, fetch_config, override_envs_and_args_launch_config,
 };
+use crate::sgx::AppDeleteResponse;
 use crate::sgx::{
     append_uuid_list, get_app_node, get_app_node_by_contract, get_one_contract, inspect_node,
-    package_entry_from_name, print_nodes, write_uuid_list, AppContract, AppDeleteResponse,
-    AppDeployResponse,
+    package_entry_from_name, print_nodes, write_uuid_list,
 };
+use crate::sgx::{AppContract, AppDeployResponse};
 use crate::utils::block_on;
 use crate::{cli_print, SimpleOutput};
 use clap::ArgMatches;
 use detee_shared::app_proto::ListAppContractsReq;
-use detee_shared::sgx::types::brain::{AppDeployConfig, Resource};
+use detee_shared::sgx::types::brain::AppDeployConfig;
+use detee_shared::sgx::types::brain::Resource;
 
 pub fn handle_app(app_matche: &ArgMatches) {
     match app_matche.subcommand() {
@@ -81,8 +83,8 @@ fn handle_deploy(
         (AppDeployConfig::from_path(file_path).unwrap(), None)
     } else {
         let vcpus = *deploy_match.get_one::<u32>("vcpus").unwrap();
-        let memory_mib = *deploy_match.get_one::<u32>("memory").unwrap();
-        let disk_size_mib = *deploy_match.get_one::<u32>("disk").unwrap() * 1024;
+        let memory_mb = *deploy_match.get_one::<u32>("memory").unwrap();
+        let disk_size_gb = *deploy_match.get_one::<u32>("disk").unwrap();
         let port =
             deploy_match.get_many::<u32>("port").unwrap_or_default().cloned().collect::<Vec<_>>();
         let package_name = deploy_match.get_one::<String>("package").unwrap().clone();
@@ -98,7 +100,7 @@ fn handle_deploy(
 
         let private_package = false;
 
-        let resource = Resource { vcpus, memory_mib, disk_size_mib, port };
+        let resource = Resource { vcpus, memory_mb, disk_size_gb, port };
         let node_pubkey = match block_on(get_app_node(resource.clone(), location.into())) {
             Ok(node) => node.node_pubkey,
             Err(e) => {

src/sgx/config.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use detee_shared::sgx::types::brain::AppDeployConfig;
-use detee_shared::sgx::types::dtpm::DtpmConfig;
+use detee_shared::sgx::types::{brain::AppDeployConfig, dtpm::DtpmConfig};
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {

src/sgx/grpc_brain.rs

@@ -65,11 +65,9 @@ impl crate::HumanOutput for AppContract {
         println!("The app has mapped ports by the node are: {mapped_ports}");
         println!(
             "The App has {} vCPUS, {}MB of memory and a disk of {} GB.",
-            app_resource.vcpus,
-            app_resource.memory_mib,
-            app_resource.disk_size_mib / 1024
+            app_resource.vcpus, app_resource.memory_mb, app_resource.disk_size_gb
         );
-        println!("You have locked {} nanocredits in the contract, that get collected at a rate of {} nanocredits per minute.",
+        println!("You have locked {} nanoLP in the contract, that get collected at a rate of {} nanoLP per minute.",
             self.locked_nano, self.nano_per_minute);
     }
 }
@@ -89,8 +87,8 @@ pub async fn new_app(app_deploy_config: AppDeployConfig) -> Result<NewAppRes> {
 
     let locked_nano = calculate_nanolp_for_app(
         resource.vcpus,
-        resource.memory_mib,
-        resource.disk_size_mib,
+        resource.memory_mb,
+        resource.disk_size_gb,
         app_deploy_config.hours,
         req.price_per_unit,
     );

src/sgx/grpc_dtpm.rs

@@ -1,21 +1,27 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use detee_sgx::prelude::*;
-use detee_sgx::HRaTlsConfigBuilder;
-use detee_shared::common_proto::Empty;
-use detee_shared::sgx::pb::dtpm_proto::DtpmGetConfigRes;
-use detee_shared::sgx::types::dtpm::FileEntry;
+use detee_sgx::{prelude::*, HRaTlsConfigBuilder};
+use detee_shared::{
+    common_proto::Empty,
+    sgx::{pb::dtpm_proto::DtpmGetConfigRes, types::dtpm::FileEntry},
+};
 use hyper_rustls::HttpsConnectorBuilder;
 use rustls::ClientConfig;
 use std::sync::{Arc, RwLock};
 use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
-use tonic::codec::CompressionEncoding;
-use tonic::transport::{Channel, Endpoint};
+use tonic::{
+    codec::CompressionEncoding,
+    transport::{Channel, Endpoint},
+};
 
-use detee_shared::sgx::pb::dtpm_proto::dtpm_config_manager_client::DtpmConfigManagerClient;
-use detee_shared::sgx::pb::dtpm_proto::{DtpmSetConfigReq, FileEntry as FileEntryPb};
-use detee_shared::sgx::types::dtpm::DtpmConfig;
+use detee_shared::sgx::{
+    pb::dtpm_proto::{
+        dtpm_config_manager_client::DtpmConfigManagerClient, DtpmSetConfigReq,
+        FileEntry as FileEntryPb,
+    },
+    types::dtpm::DtpmConfig,
+};
 
 use crate::config::Config;
 use crate::sgx::utils::hratls_url_and_mr_enclave_from_app_id;

src/sgx/mod.rs

@@ -8,14 +8,16 @@ pub mod packaging;
 pub mod utils;
 
 use crate::config::Config;
-use crate::constants::HRATLS_APP_PORT;
 use crate::snp;
-use crate::utils::{block_on, shorten_string};
-use detee_shared::app_proto::{
+use crate::utils::shorten_string;
+use crate::{constants::HRATLS_APP_PORT, utils::block_on};
+use detee_shared::{
+    app_proto::{
         AppContract as AppContractPB, AppNodeFilters, AppNodeListResp, AppResource,
         ListAppContractsReq, NewAppRes,
+    },
+    sgx::types::brain::Resource,
 };
-use detee_shared::sgx::types::brain::Resource;
 use grpc_brain::get_one_app_node;
 use serde::{Deserialize, Serialize};
 use std::sync::LazyLock;
@@ -43,10 +45,10 @@ pub struct AppContract {
     #[tabled(rename = "Cores")]
     pub vcpus: u32,
     #[tabled(rename = "Mem (MB)")]
-    pub memory_mib: u32,
+    pub memory_mb: u32,
     #[tabled(rename = "Disk (GB)")]
-    pub disk_size_mib: u32,
-    #[tabled(rename = "credits/h")]
+    pub disk_size_gb: u32,
+    #[tabled(rename = "LP/h")]
     pub cost_h: String,
     #[tabled(rename = "time left", display_with = "display_mins")]
     pub time_left: u64,
@@ -137,7 +139,7 @@ impl From<AppContractPB> for AppContract {
             }
         };
 
-        let AppResource { vcpus, memory_mib, disk_size_mib, .. } =
+        let AppResource { vcpus, memory_mb, disk_size_gb, .. } =
             brain_app_contract.resource.unwrap_or_default();
 
         let exposed_host_ports = brain_app_contract
@@ -151,8 +153,8 @@ impl From<AppContractPB> for AppContract {
             uuid: brain_app_contract.uuid,
             name: brain_app_contract.app_name,
             vcpus,
-            memory_mib,
-            disk_size_mib,
+            memory_mb,
+            disk_size_gb,
             cost_h: format!(
                 "{:.4}",
                 (brain_app_contract.nano_per_minute * 60) as f64 / 1_000_000_000.0
@@ -225,12 +227,12 @@ impl crate::HumanOutput for AppDeleteResponse {
 
 pub async fn get_app_node(
     resource: Resource,
-    location: snp::Location,
+    location: snp::deploy::Location,
 ) -> Result<AppNodeListResp, grpc_brain::Error> {
     let app_node_filter = AppNodeFilters {
         vcpus: resource.vcpus,
-        memory_mib: resource.memory_mib,
-        storage_mib: resource.disk_size_mib,
+        memory_mb: resource.memory_mb,
+        storage_gb: resource.disk_size_gb,
         country: location.country.clone().unwrap_or_default(),
         region: location.region.clone().unwrap_or_default(),
         city: location.city.clone().unwrap_or_default(),
@@ -266,7 +268,7 @@ impl From<AppNodeListResp> for TabledAppNode {
             operator: brain_node.operator,
             location: brain_node.city + ", " + &brain_node.region + ", " + &brain_node.country,
             public_ip: brain_node.ip,
-            price: format!("{} nanocredits/min", brain_node.price),
+            price: format!("{} nanoLP/min", brain_node.price),
             reports: brain_node.reports.len(),
         }
     }
@@ -308,8 +310,7 @@ fn write_uuid_list(app_contracts: &[AppContract]) -> Result<(), Error> {
 }
 
 pub fn append_uuid_list(uuid: &str, app_name: &str) -> Result<(), Error> {
-    use std::fs::OpenOptions;
-    use std::io::prelude::*;
+    use std::{fs::OpenOptions, io::prelude::*};
     let mut file =
         OpenOptions::new().create(true).append(true).open(Config::app_uuid_list_path()?).unwrap();
     writeln!(file, "{uuid}\t{app_name}")?;

src/sgx/utils.rs

@@ -1,13 +1,17 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::constants::HRATLS_APP_PORT;
+use crate::sgx::get_one_contract;
 use crate::sgx::grpc_brain::new_app;
-use crate::sgx::grpc_dtpm::{connect_app_dtpm_client, set_config_pb, upload_files_pb};
-use crate::sgx::{get_one_contract, package_entry_from_name};
+use crate::sgx::grpc_dtpm::connect_app_dtpm_client;
+use crate::sgx::grpc_dtpm::set_config_pb;
+use crate::sgx::grpc_dtpm::upload_files_pb;
+use crate::sgx::package_entry_from_name;
 use detee_shared::app_proto::NewAppRes;
 use detee_shared::sgx::pb::dtpm_proto::DtpmSetConfigReq;
 use detee_shared::sgx::types::brain::AppDeployConfig;
-use detee_shared::sgx::types::dtpm::{DtpmConfig, EnvironmentEntry};
+use detee_shared::sgx::types::dtpm::DtpmConfig;
+use detee_shared::sgx::types::dtpm::EnvironmentEntry;
 use tokio_retry::strategy::FixedInterval;
 use tokio_retry::Retry;
 
@@ -68,15 +72,14 @@ pub async fn fetch_config(package_name: &str) -> Result<DtpmConfig, Error> {
 
 pub fn calculate_nanolp_for_app(
     vcpus: u32,
-    memory_mib: u32,
-    disk_size_mib: u32,
+    memory_mb: u32,
+    disk_size_gb: u32,
     hours: u64,
     node_price: u64,
 ) -> u64 {
     // this calculation needs to match the calculation of the network
-    let total_units = (vcpus as f64 * 5f64)
-        + (memory_mib as f64 / 200f64)
-        + (disk_size_mib as f64 / 1024f64 / 10f64);
+    let total_units =
+        (vcpus as f64 * 5f64) + (memory_mb as f64 / 200f64) + (disk_size_gb as f64 / 10f64);
     let locked_nano = (hours as f64 * 60f64 * total_units * node_price as f64) as u64;
     eprintln!(
             "Node price: {}/unit/minute. Total Units for hardware requested: {:.4}. Locking {} LP (offering the App for {} hours).",

src/snp/cli_handler.rs

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{cli_print, general, name_generator, snp, SimpleOutput};
+use crate::general;
+use crate::name_generator;
+use crate::snp;
+use crate::{cli_print, SimpleOutput};
 use clap::ArgMatches;
 use std::error::Error;
 
@@ -27,14 +30,7 @@ pub fn handle_vm(matches: &ArgMatches) {
 
 pub fn handle_vm_nodes(matches: &ArgMatches) {
     match matches.subcommand() {
-        Some(("search", arguments)) => {
-            let location = arguments.get_one::<String>("location").unwrap().as_str();
-            cli_print(snp::search_nodes(location.into()).map_err(Into::into));
-        }
-        Some(("offers", arguments)) => {
-            let location = arguments.get_one::<String>("location").unwrap().as_str();
-            cli_print(snp::print_node_offers(location.into()).map_err(Into::into));
-        }
+        Some(("search", _)) => cli_print(snp::print_nodes().map_err(Into::into)),
         Some(("inspect", path_subcommand)) => {
             let ip: String = path_subcommand.get_one::<String>("ip").unwrap().clone();
             cli_print(snp::inspect_node(ip).map_err(Into::into));
@@ -73,8 +69,8 @@ fn handle_vm_deploy(matches: &ArgMatches) -> Result<snp::VmSshArgs, Box<dyn Erro
         ipv4,
         public_ipv6: false,
         vcpus: *matches.get_one::<u32>("vcpus").unwrap(),
-        memory_gib: *matches.get_one::<u32>("memory").unwrap(),
-        disk_size_gib: *matches.get_one::<u32>("disk").unwrap(),
+        memory_mb: *matches.get_one::<u32>("memory").unwrap(),
+        disk_size_gb: *matches.get_one::<u32>("disk").unwrap(),
         dtrfs: None,
         hours: *matches.get_one::<u32>("hours").unwrap(),
         price: *matches.get_one::<u64>("price").unwrap(),
@@ -96,6 +92,10 @@ fn handle_vm_update(update_vm_args: &ArgMatches) -> Result<SimpleOutput, Box<dyn
     let uuid = update_vm_args.get_one::<String>("uuid").unwrap().clone();
     let hostname = update_vm_args.get_one::<String>("hostname").unwrap().clone();
     let memory = *update_vm_args.get_one::<u32>("memory").unwrap();
+    if memory > 0 && memory < 800 {
+        log::error!("At least 800MB of memory must be assgined to the VM");
+        return Ok(SimpleOutput::from(""));
+    }
     snp::update::Request::process_request(
         hostname,
         &uuid,

src/snp/deploy.rs

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use super::grpc::{self, proto};
-use super::{injector, Distro, Dtrfs, Error, VmSshArgs, DEFAULT_ARCHLINUX, DEFAULT_DTRFS};
+use super::{
+    grpc::{self, proto},
+    injector, Distro, Dtrfs, Error, VmSshArgs, DEFAULT_ARCHLINUX, DEFAULT_DTRFS,
+};
 use crate::config::Config;
 use crate::utils::block_on;
 use log::{debug, info};
@@ -13,18 +15,44 @@ pub enum IPv4Config {
     PublicIPv4,
 }
 
+//  TODO: push this out of snp module
+#[derive(Serialize, Deserialize, Default)]
+pub struct Location {
+    pub node_ip: Option<String>,
+    pub country: Option<String>,
+    pub region: Option<String>,
+    pub city: Option<String>,
+}
+
+impl From<&str> for Location {
+    fn from(s: &str) -> Self {
+        match s {
+            "Canada" => Self { country: Some("CA".to_string()), ..Default::default() },
+            "Montreal" => Self { city: Some("Montréal".to_string()), ..Default::default() },
+            "Vancouver" => Self { city: Some("Vancouver".to_string()), ..Default::default() },
+            "US" => Self { country: Some("US".to_string()), ..Default::default() },
+            "California" => Self { country: Some("US".to_string()), ..Default::default() },
+            "France" => Self { country: Some("FR".to_string()), ..Default::default() },
+            "GB" => Self { country: Some("GB".to_string()), ..Default::default() },
+            "Random" => Self { ..Default::default() },
+            "DE" => Self { country: Some("DE".to_string()), ..Default::default() },
+            _ => Self { city: Some("Vancouver".to_string()), ..Default::default() },
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct Request {
     pub hostname: String,
     pub hours: u32,
     // price per unit per minute
     pub price: u64,
-    pub location: super::Location,
+    pub location: Location,
     pub ipv4: IPv4Config,
     pub public_ipv6: bool,
     pub vcpus: u32,
-    pub memory_gib: u32,
-    pub disk_size_gib: u32,
+    pub memory_mb: u32,
+    pub disk_size_gb: u32,
     pub dtrfs: Option<Dtrfs>,
     pub distro: Option<Distro>,
 }
@@ -42,8 +70,8 @@ impl Request {
     }
 
     pub fn deploy(&self) -> Result<VmSshArgs, Error> {
-        let (vcpus, new_vm_resp) = self.calculate_and_send_request()?;
-        info!("Got confirmation from the node that the VM started.");
+        let (node_ip, new_vm_resp) = self.send_vm_request()?;
+        info!("Got confirmation from the node {node_ip} that VM started.");
         debug!("IPs and ports assigned by node are: {new_vm_resp:#?}");
         if !new_vm_resp.error.is_empty() {
             return Err(Error::Node(new_vm_resp.error));
@@ -55,7 +83,7 @@ impl Request {
         let args = new_vm_resp.args.ok_or(Error::NoMeasurement)?;
         let measurement_args = injector::Args {
             uuid: new_vm_resp.uuid.clone(),
-            vcpus,
+            vcpus: self.vcpus,
             kernel: kernel_sha,
             initrd: dtrfs_sha,
             args: args.clone(),
@@ -79,106 +107,10 @@ impl Request {
         Ok(ssh_args)
     }
 
-    /// returns number of vCPUs and response from the daemon
-    fn calculate_and_send_request(&self) -> Result<(u32, proto::NewVmResp), Error> {
-        let new_vm_req = self.get_cheapest_offer()?;
-        let vcpus = new_vm_req.vcpus;
-
-        eprintln!(
-            "Locking {} credits for {} hours of the following HW spec: {} vCPUs, {} MiB Mem, {} MiB Disk",
-            new_vm_req.locked_nano as f64 / 1_000_000_000_f64,
-            self.hours,
-            new_vm_req.vcpus,
-            new_vm_req.memory_mib,
-            new_vm_req.disk_size_mib
-        );
-
-        // eprint!(
-        //     "Node price: {}/unit/minute. Total Units for hardware requested: {}. ",
-        //     node_price as f64 / 1_000_000_000.0,
-        //     total_units,
-        // );
-        // eprintln!(
-        //     "Locking {} LP (offering the VM for {} hours).",
-        //     locked_nano as f64 / 1_000_000_000.0,
-        //     hours
-        // );
-
-        let new_vm_resp = block_on(grpc::create_vm(new_vm_req))?;
-        if !new_vm_resp.error.is_empty() {
-            return Err(Error::Node(new_vm_resp.error));
-        }
-        Ok((vcpus, new_vm_resp))
-    }
-
-    fn get_cheapest_offer(&self) -> Result<proto::NewVmReq, Error> {
-        let (free_ports, offers_ipv4) = match &self.ipv4 {
-            IPv4Config::PublishPorts(vec) => (vec.len() as u32, false),
-            IPv4Config::PublicIPv4 => (0, true),
-        };
-        let filters = proto::VmNodeFilters {
-            free_ports,
-            offers_ipv4,
-            offers_ipv6: self.public_ipv6,
-            vcpus: self.vcpus,
-            memory_mib: self.memory_gib * 1024,
-            storage_mib: self.disk_size_gib * 1024,
-            country: self.location.country.clone().unwrap_or_default(),
-            region: self.location.region.clone().unwrap_or_default(),
-            city: self.location.city.clone().unwrap_or_default(),
-            ip: self.location.node_ip.clone().unwrap_or_default(),
-            node_pubkey: String::new(),
-        };
-        let node_list = match block_on(grpc::get_node_list(filters)) {
-            Ok(node_list) => Ok(node_list),
-            Err(e) => {
-                log::error!("Coult not get node from brain: {e:?}");
-                Err(Error::NoValidNodeFound)
-            }
-        }?;
-
-        let mut node_list_iter = node_list.iter();
-        let mut final_request = self.calculate_vm_request(
-            Config::get_detee_wallet()?,
-            node_list_iter.next().ok_or(Error::NoValidNodeFound)?,
-        );
-        while let Some(node) = node_list_iter.next() {
-            let new_vm_req = self.calculate_vm_request(Config::get_detee_wallet()?, node);
-            if new_vm_req.locked_nano < final_request.locked_nano {
-                final_request = new_vm_req;
-            }
-        }
-
-        Ok(final_request)
-    }
-
-    fn calculate_vm_request(
-        &self,
-        admin_pubkey: String,
-        node: &proto::VmNodeListResp,
-    ) -> proto::NewVmReq {
-        let memory_per_cpu = node.memory_mib / node.vcpus;
-        let disk_per_cpu = node.disk_mib / node.vcpus;
-        let mut vcpus = self.vcpus;
-        if vcpus < (self.memory_gib * 1024).div_ceil(memory_per_cpu as u32) {
-            vcpus = (self.memory_gib * 1024).div_ceil(memory_per_cpu as u32);
-        }
-        if vcpus < (self.disk_size_gib * 1024).div_ceil(disk_per_cpu as u32) {
-            vcpus = (self.disk_size_gib * 1024).div_ceil(disk_per_cpu as u32);
-        }
-
-        let memory_mib = vcpus * memory_per_cpu as u32;
-        let disk_size_mib = vcpus * disk_per_cpu as u32;
-
-        let nanocredits = super::calculate_nanocredits(
-            vcpus,
-            memory_mib,
-            disk_size_mib,
-            node.public_ipv4,
-            self.hours,
-            node.price,
-        );
-
+    // returns node IP and data regarding the new VM
+    fn send_vm_request(&self) -> Result<(String, proto::NewVmResp), Error> {
+        let admin_pubkey = Config::get_detee_wallet()?;
+        let node = self.get_node()?;
         let (extra_ports, public_ipv4): (Vec<u32>, bool) = match &self.ipv4 {
             IPv4Config::PublishPorts(vec) => (vec.to_vec(), false),
             IPv4Config::PublicIPv4 => (Vec::new(), true),
@@ -192,31 +124,63 @@ impl Request {
                 DEFAULT_DTRFS.dtrfs_sha.clone(),
             ),
         };
-
+        let locked_nano = super::calculate_nanolp(
+            self.vcpus,
+            self.memory_mb,
+            self.disk_size_gb,
+            public_ipv4,
+            self.hours,
+            self.price,
+        );
         let brain_req = proto::NewVmReq {
             uuid: String::new(),
             hostname: self.hostname.clone(),
             admin_pubkey,
-            node_pubkey: node.node_pubkey.clone(),
+            node_pubkey: node.node_pubkey,
             extra_ports,
             public_ipv4,
             public_ipv6: self.public_ipv6,
-            disk_size_mib,
-            vcpus,
-            memory_mib,
+            disk_size_gb: self.disk_size_gb,
+            vcpus: self.vcpus,
+            memory_mb: self.memory_mb,
             kernel_url,
             kernel_sha,
             dtrfs_url,
             dtrfs_sha,
-            price_per_unit: node.price,
-            locked_nano: nanocredits,
+            price_per_unit: self.price,
+            locked_nano,
         };
+        let new_vm_resp = block_on(grpc::create_vm(brain_req))?;
+        if !new_vm_resp.error.is_empty() {
+            return Err(Error::Node(new_vm_resp.error));
+        }
+        Ok((node.ip, new_vm_resp))
+    }
 
-        debug!(
-            "Node {} can offer the VM at {} nanocredits for {} hours. Spec: {} vCPUs, {} MiB mem, {} MiB disk.",
-            node.ip, brain_req.locked_nano, self.hours, brain_req.vcpus, brain_req.memory_mib, brain_req.disk_size_mib
-        );
-
-        brain_req
+    pub fn get_node(&self) -> Result<proto::VmNodeListResp, Error> {
+        let (free_ports, offers_ipv4) = match &self.ipv4 {
+            IPv4Config::PublishPorts(vec) => (vec.len() as u32, false),
+            IPv4Config::PublicIPv4 => (0, true),
+        };
+        let filters = proto::VmNodeFilters {
+            free_ports,
+            offers_ipv4,
+            offers_ipv6: self.public_ipv6,
+            vcpus: self.vcpus,
+            memory_mb: self.memory_mb,
+            storage_gb: self.disk_size_gb,
+            country: self.location.country.clone().unwrap_or_default(),
+            region: self.location.region.clone().unwrap_or_default(),
+            city: self.location.city.clone().unwrap_or_default(),
+            ip: self.location.node_ip.clone().unwrap_or_default(),
+            node_pubkey: String::new(),
+        };
+        match block_on(grpc::get_one_node(filters)) {
+            Ok(node) => Ok(node),
+            Err(e) => {
+                log::error!("Coult not get node from brain: {e:?}");
+                Err(Error::NoValidNodeFound)
+            }
+        }
     }
 }

src/snp/grpc.rs

@@ -10,10 +10,9 @@ use crate::config::Config;
 use crate::utils::{self, sign_request};
 use lazy_static::lazy_static;
 use log::{debug, info, warn};
-use proto::brain_vm_cli_client::BrainVmCliClient;
 use proto::{
-    DeleteVmReq, ExtendVmReq, ListVmContractsReq, NewVmReq, NewVmResp, UpdateVmReq, UpdateVmResp,
-    VmContract, VmNodeFilters, VmNodeListResp,
+    brain_vm_cli_client::BrainVmCliClient, DeleteVmReq, ExtendVmReq, ListVmContractsReq, NewVmReq,
+    NewVmResp, UpdateVmReq, UpdateVmResp, VmContract, VmNodeFilters, VmNodeListResp,
 };
 use tokio_stream::StreamExt;
 use tonic::metadata::errors::InvalidMetadataValue;
@@ -75,7 +74,7 @@ impl crate::HumanOutput for VmContract {
             "The VM has {} vCPUS, {}MB of memory and a disk of {} GB.",
             self.vcpus, self.memory_mb, self.disk_size_gb
         );
-        println!("You have locked {} nanocredits in the contract, that get collected at a rate of {} nanocredits per minute.",
+        println!("You have locked {} nanoLP in the contract, that get collected at a rate of {} nanoLP per minute.",
             self.locked_nano, self.nano_per_minute);
     }
 }
@@ -183,7 +182,7 @@ pub async fn extend_vm(uuid: String, admin_pubkey: String, locked_nano: u64) ->
         Ok(confirmation) => {
             log::debug!("VM contract extension confirmation: {confirmation:?}");
             log::info!(
-                "VM contract got updated. It now has {} credits locked for the VM.",
+                "VM contract got updated. It now has {} LP locked for the VM.",
                 locked_nano as f64 / 1_000_000_000.0
             );
         }

src/snp/injector.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::Config;
-use crate::snp::grpc::proto;
+use crate::{config::Config, snp::grpc::proto};
 use log::debug;
 use std::net::IpAddr;
 

src/snp/mod.rs

@@ -6,9 +6,12 @@ pub mod grpc;
 mod injector;
 pub mod update;
 
-use crate::config::{self, Config};
-use crate::snp;
-use crate::utils::{block_on, display_mib_or_gib, shorten_string};
+use crate::utils::block_on;
+use crate::utils::shorten_string;
+use crate::{
+    config::{self, Config},
+    snp,
+};
 use grpc::proto;
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
@@ -36,32 +39,6 @@ pub enum Error {
     Injector(#[from] injector::Error),
 }
 
-//  TODO: push this out of snp module
-#[derive(Serialize, Deserialize, Default)]
-pub struct Location {
-    pub node_ip: Option<String>,
-    pub country: Option<String>,
-    pub region: Option<String>,
-    pub city: Option<String>,
-}
-
-impl From<&str> for Location {
-    fn from(s: &str) -> Self {
-        match s {
-            "Canada" => Self { country: Some("CA".to_string()), ..Default::default() },
-            "Montreal" => Self { city: Some("Montréal".to_string()), ..Default::default() },
-            "Vancouver" => Self { city: Some("Vancouver".to_string()), ..Default::default() },
-            "US" => Self { country: Some("US".to_string()), ..Default::default() },
-            "California" => Self { country: Some("US".to_string()), ..Default::default() },
-            "France" => Self { country: Some("FR".to_string()), ..Default::default() },
-            "GB" => Self { country: Some("GB".to_string()), ..Default::default() },
-            "DE" => Self { country: Some("DE".to_string()), ..Default::default() },
-            "Any" => Self { ..Default::default() },
-            _ => Self { ..Default::default() },
-        }
-    }
-}
-
 #[derive(Serialize, Default)]
 pub struct VmSshArgs {
     uuid: String,
@@ -180,12 +157,12 @@ pub struct VmContract {
     pub uuid: String,
     pub hostname: String,
     #[tabled(rename = "Cores")]
-    pub vcpus: u64,
-    #[tabled(rename = "Mem", display_with = "display_mib_or_gib")]
-    pub mem: u64,
-    #[tabled(rename = "Disk", display_with = "display_mib_or_gib")]
-    pub disk: u64,
-    #[tabled(rename = "credits/h")]
+    pub vcpus: u32,
+    #[tabled(rename = "Mem (MB)")]
+    pub mem: u32,
+    #[tabled(rename = "Disk")]
+    pub disk: u32,
+    #[tabled(rename = "LP/h")]
     pub cost_h: f64,
     #[tabled(rename = "time left", display_with = "display_mins")]
     pub time_left: u64,
@@ -212,9 +189,9 @@ impl From<proto::VmContract> for VmContract {
         Self {
             uuid: brain_contract.uuid,
             hostname: brain_contract.hostname,
-            vcpus: brain_contract.vcpus as u64,
-            mem: brain_contract.memory_mb as u64,
-            disk: brain_contract.disk_size_gb as u64,
+            vcpus: brain_contract.vcpus,
+            mem: brain_contract.memory_mb,
+            disk: brain_contract.disk_size_gb,
             location: brain_contract.location,
             cost_h: (brain_contract.nano_per_minute * 60) as f64 / 1_000_000_000.0,
             time_left: brain_contract.locked_nano / brain_contract.nano_per_minute,
@@ -224,22 +201,12 @@ impl From<proto::VmContract> for VmContract {
 
 #[derive(Tabled, Debug, Serialize, Deserialize)]
 pub struct TabledVmNode {
-    #[tabled(rename = "Operator", display_with = "shorten_string")]
+    #[tabled(rename = "Operator")]
     pub operator: String,
-    #[tabled(rename = "Main IP")]
-    pub main_ip: String,
     #[tabled(rename = "City, Region, Country")]
     pub location: String,
-    #[tabled(rename = "Cores")]
-    pub vcpus: u64,
-    #[tabled(rename = "Mem", display_with = "display_mib_or_gib")]
-    pub memory_mib: u64,
-    #[tabled(rename = "Disk", display_with = "display_mib_or_gib")]
-    pub disk_mib: u64,
-    #[tabled(rename = "Extra IPv4", display_with = "display_ip_support")]
-    pub public_ipv4: bool,
-    #[tabled(rename = "IPv6", display_with = "display_ip_support")]
-    pub public_ipv6: bool,
+    #[tabled(rename = "IP")]
+    pub public_ip: String,
     #[tabled(rename = "Price per unit")]
     pub price: String,
     #[tabled(rename = "Reports")]
@@ -251,14 +218,9 @@ impl From<proto::VmNodeListResp> for TabledVmNode {
         Self {
             operator: brain_node.operator,
             location: brain_node.city + ", " + &brain_node.region + ", " + &brain_node.country,
-            main_ip: brain_node.ip,
-            price: format!("{} nano/min", brain_node.price),
+            public_ip: brain_node.ip,
+            price: format!("{} nanoLP/min", brain_node.price),
             reports: brain_node.reports.len(),
-            vcpus: brain_node.vcpus,
-            memory_mib: brain_node.memory_mib,
-            disk_mib: brain_node.disk_mib,
-            public_ipv4: brain_node.public_ipv4,
-            public_ipv6: brain_node.public_ipv6,
         }
     }
 }
@@ -350,8 +312,7 @@ fn write_uuid_list(contracts: &[VmContract]) -> Result<(), Error> {
 }
 
 pub fn append_uuid_list(uuid: &str, hostname: &str) -> Result<(), Error> {
-    use std::fs::OpenOptions;
-    use std::io::prelude::*;
+    use std::{fs::OpenOptions, io::prelude::*};
     let mut file =
         OpenOptions::new().create(true).append(true).open(Config::vm_uuid_list_path()?)?;
     writeln!(file, "{uuid}\t{hostname}")?;
@@ -368,104 +329,21 @@ impl super::HumanOutput for Vec<proto::VmNodeListResp> {
     }
 }
 
-pub fn search_nodes(location: Location) -> Result<Vec<proto::VmNodeListResp>, Error> {
+pub fn print_nodes() -> Result<Vec<proto::VmNodeListResp>, Error> {
     log::debug!("This will support flags in the future, but we have only one node atm.");
-    let req = proto::VmNodeFilters {
-        city: location.city.unwrap_or_default(),
-        country: location.country.unwrap_or_default(),
-        region: location.region.unwrap_or_default(),
-        ..Default::default()
-    };
+    let req = proto::VmNodeFilters { ..Default::default() };
     Ok(block_on(grpc::get_node_list(req))?)
 }
 
-#[derive(Tabled, Debug, Serialize, Deserialize)]
-pub struct NodeOffer {
-    #[tabled(rename = "Location")]
-    pub location: String,
-    #[tabled(rename = "Cores")]
-    pub vcpus: u64,
-    #[tabled(rename = "Mem", display_with = "display_mib_or_gib")]
-    pub mem: u64,
-    #[tabled(rename = "Disk", display_with = "display_mib_or_gib")]
-    pub disk: u64,
-    #[tabled(rename = "Public IPv4", display_with = "display_ip_support")]
-    pub ipv4: bool,
-    #[tabled(rename = "Public IPv6", display_with = "display_ip_support")]
-    pub ipv6: bool,
-    #[tabled(rename = "cost/h")]
-    pub cost_h: f64,
-    #[tabled(rename = "cost/m")]
-    pub cost_m: f64,
-}
-
-fn display_ip_support(support: &bool) -> String {
-    match support {
-        true => "Available".to_string(),
-        false => "Unavailable".to_string(),
-    }
-}
-
-impl super::HumanOutput for Vec<NodeOffer> {
-    fn human_cli_print(&self) {
-        let style = tabled::settings::Style::rounded();
-        let mut table = tabled::Table::new(self);
-        table.with(style);
-        println!("{table}");
-    }
-}
-
-pub fn print_node_offers(location: Location) -> Result<Vec<NodeOffer>, Error> {
-    log::debug!("This will support flags in the future, but we have only one node atm.");
-    let req = proto::VmNodeFilters {
-        city: location.city.unwrap_or_default(),
-        country: location.country.unwrap_or_default(),
-        region: location.region.unwrap_or_default(),
-        ..Default::default()
-    };
-    let node_list = block_on(grpc::get_node_list(req))?;
-    let mut offers: Vec<NodeOffer> = Vec::new();
-    for node in node_list.iter() {
-        let mem_per_cpu = node.memory_mib / node.vcpus;
-        let disk_per_cpu = node.disk_mib / node.vcpus;
-        for i in 1..node.vcpus {
-            let price_per_month = calculate_nanocredits(
-                (node.vcpus * i) as u32,
-                (mem_per_cpu * i) as u32,
-                (disk_per_cpu * i) as u32,
-                false,
-                732,
-                node.price,
-            ) as f64
-                / 1_000_000_000_f64;
-            let price_per_hour = price_per_month / 732_f64;
-            let price_per_month = (price_per_month * 100.0).round() / 100.0;
-            let price_per_hour = (price_per_hour * 1000.0).round() / 1000.0;
-            offers.push(NodeOffer {
-                location: node.city.clone() + ", " + &node.region + ", " + &node.country,
-                vcpus: i,
-                mem: i * mem_per_cpu,
-                disk: i * disk_per_cpu,
-                cost_h: price_per_hour,
-                cost_m: price_per_month,
-                ipv4: node.public_ipv4,
-                ipv6: node.public_ipv6,
-            });
-        }
-    }
-    offers.sort_by_key(|n| n.cost_m as u64);
-    Ok(offers)
-}
-
 pub fn inspect_node(ip: String) -> Result<proto::VmNodeListResp, Error> {
     let req = proto::VmNodeFilters { ip, ..Default::default() };
     Ok(block_on(grpc::get_one_node(req))?)
 }
 
-pub fn calculate_nanocredits(
+pub fn calculate_nanolp(
     vcpus: u32,
     memory_mb: u32,
-    disk_size_mib: u32,
+    disk_size_gb: u32,
     public_ipv4: bool,
     hours: u32,
     node_price: u64,
@@ -473,9 +351,19 @@ pub fn calculate_nanocredits(
     // this calculation needs to match the calculation of the network
     let total_units = (vcpus as u64 * 10)
         + ((memory_mb + 256) as u64 / 200)
-        + (disk_size_mib as u64 / 1024 / 10)
+        + (disk_size_gb as u64 / 10)
         + (public_ipv4 as u64 * 10);
     let locked_nano = hours as u64 * 60 * total_units * node_price;
+    eprint!(
+        "Node price: {}/unit/minute. Total Units for hardware requested: {}. ",
+        node_price as f64 / 1_000_000_000.0,
+        total_units,
+    );
+    eprintln!(
+        "Locking {} LP (offering the VM for {} hours).",
+        locked_nano as f64 / 1_000_000_000.0,
+        hours
+    );
     locked_nano
 }
 

src/snp/update.rs

@@ -1,7 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
-use super::grpc::{self, proto};
-use super::{injector, Dtrfs, Error};
+use super::{
+    grpc::{self, proto},
+    injector, Dtrfs, Error,
+};
 use crate::config::Config;
 use crate::utils::block_on;
 use log::{debug, info};
@@ -10,8 +12,8 @@ use log::{debug, info};
 pub struct Request {
     hostname: String,
     vcpus: u32,
-    memory_mib: u32,
-    disk_size_mib: u32,
+    memory_mb: u32,
+    disk_size_gb: u32,
     dtrfs: Option<Dtrfs>,
 }
 
@@ -32,8 +34,7 @@ impl Request {
                 Some(Dtrfs::load_from_file(path)?)
             }
         };
-        let req =
-            Self { hostname, vcpus, memory_mib: memory_mb, disk_size_mib: disk_size_gb, dtrfs };
+        let req = Self { hostname, vcpus, memory_mb, disk_size_gb, dtrfs };
         if req == Self::default() {
             log::info!("Skipping hardware upgrade (no arguments specified).");
             return Ok(());
@@ -54,7 +55,7 @@ impl Request {
         let updated_contract = block_on(grpc::get_contract_by_uuid(uuid))?;
         debug!("Got the current contract for the VM after update. {updated_contract:#?}");
 
-        if !(self.vcpus != 0 || self.memory_mib != 0 || self.dtrfs.is_some()) {
+        if !(self.vcpus != 0 || self.dtrfs.is_some()) {
             eprintln!("vCPUs and kernel did not get modified. Secret injection is not required.");
             return Ok(());
         }
@@ -69,7 +70,12 @@ impl Request {
         };
         let measurement = measurement_args.get_measurement()?;
 
-        injector::execute(measurement, args.dtrfs_api_endpoint, None, &updated_contract.hostname)?;
+            injector::execute(
+                measurement,
+                args.dtrfs_api_endpoint,
+                None,
+                &updated_contract.hostname,
+            )?;
 
         Ok(())
     }
@@ -84,9 +90,9 @@ impl Request {
             uuid: uuid.to_string(),
             hostname: self.hostname.clone(),
             admin_pubkey: Config::get_detee_wallet()?,
-            disk_size_mib: self.disk_size_mib * 1024,
+            disk_size_gb: self.disk_size_gb,
             vcpus: self.vcpus,
-            memory_mib: self.memory_mib * 1024,
+            memory_mb: self.memory_mb,
             kernel_url,
             kernel_sha,
             dtrfs_url,

src/utils.rs

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::Config;
-use tonic::metadata::errors::InvalidMetadataValue;
-use tonic::metadata::AsciiMetadataValue;
-use tonic::Request;
+use tonic::{
+    metadata::{errors::InvalidMetadataValue, AsciiMetadataValue},
+    Request,
+};
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
@@ -44,19 +45,6 @@ pub fn shorten_string(my_string: &String) -> String {
     }
 }
 
-pub fn display_mib_or_gib(value: &u64) -> String {
-    if *value >= 1024 {
-        if *value < 102400 {
-            let value = (value / 102) as f64;
-            format!("{}G", value / 10_f64)
-        } else {
-            format!("{}G", value / 1024)
-        }
-    } else {
-        format!("{}M", value)
-    }
-}
-
 #[macro_export]
 macro_rules! call_with_follow_redirect {
     (