diff --git a/Cargo.toml b/Cargo.toml
index 0873a78..ef0b906 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ uuid = { version = "1.3.0", features = [
   "serde",
 ] }
 reqwest = { version = "0.11", features = ["json"] }
-mostro-core = "0.3.13"
+mostro-core = { path = "../mostro-core" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.16", features = ["env-filter"] }
 config = "0.13.3"
diff --git a/src/app.rs b/src/app.rs
index f82d376..aba8627 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -28,7 +28,7 @@ use crate::app::take_sell::take_sell_action;
 use crate::lightning::LndConnector;
 
 use anyhow::Result;
-use mostro_core::{Action, Message};
+use mostro_core::message::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use std::sync::Arc;
@@ -57,85 +57,90 @@ pub async fn run(
                     if let Ok(m) = message {
                         let message = Message::from_json(&m);
                         if let Ok(msg) = message {
-                            if msg.verify() {
-                                match msg.action {
-                                    Action::Order => {
-                                        order_action(msg, &event, &my_keys, &client, &pool).await?;
-                                    }
-                                    Action::TakeSell => {
-                                        take_sell_action(msg, &event, &my_keys, &client, &pool)
+                            if msg.get_inner_message_kind().verify() {
+                                if let Some(action) = msg.inner_action() {
+                                    match action {
+                                        Action::NewOrder => {
+                                            order_action(msg, &event, &my_keys, &client, &pool)
+                                                .await?;
+                                        }
+                                        Action::TakeSell => {
+                                            take_sell_action(msg, &event, &my_keys, &client, &pool)
+                                                .await?;
+                                        }
+                                        Action::TakeBuy => {
+                                            take_buy_action(msg, &event, &my_keys, &client, &pool)
+                                                .await?;
+                                        }
+                                        Action::FiatSent => {
+                                            fiat_sent_action(msg, &event, &my_keys, &client, &pool)
+                                                .await?;
+                                        }
+                                        Action::Release => {
+                                            release_action(
+                                                msg, &event, &my_keys, &client, &pool, ln_client,
+                                            )
                                             .await?;
-                                    }
-                                    Action::TakeBuy => {
-                                        take_buy_action(msg, &event, &my_keys, &client, &pool)
+                                        }
+                                        Action::Cancel => {
+                                            cancel_action(
+                                                msg, &event, &my_keys, &client, &pool, ln_client,
+                                            )
                                             .await?;
-                                    }
-                                    Action::FiatSent => {
-                                        fiat_sent_action(msg, &event, &my_keys, &client, &pool)
+                                        }
+                                        Action::AddInvoice => {
+                                            add_invoice_action(
+                                                msg, &event, &my_keys, &client, &pool,
+                                            )
                                             .await?;
-                                    }
-                                    Action::Release => {
-                                        release_action(
-                                            msg, &event, &my_keys, &client, &pool, ln_client,
-                                        )
-                                        .await?;
-                                    }
-                                    Action::Cancel => {
-                                        cancel_action(
-                                            msg, &event, &my_keys, &client, &pool, ln_client,
-                                        )
-                                        .await?;
-                                    }
-                                    Action::AddInvoice => {
-                                        add_invoice_action(msg, &event, &my_keys, &client, &pool)
+                                        }
+                                        Action::PayInvoice => todo!(),
+                                        Action::RateUser => {
+                                            update_user_reputation_action(
+                                                msg,
+                                                &event,
+                                                &my_keys,
+                                                &client,
+                                                &pool,
+                                                rate_list.clone(),
+                                            )
                                             .await?;
-                                    }
-                                    Action::PayInvoice => todo!(),
-                                    Action::RateUser => {
-                                        update_user_reputation_action(
-                                            msg,
-                                            &event,
-                                            &my_keys,
-                                            &client,
-                                            &pool,
-                                            rate_list.clone(),
-                                        )
-                                        .await?;
-                                    }
-                                    Action::Dispute => {
-                                        dispute_action(msg, &event, &my_keys, &client, &pool)
+                                        }
+                                        Action::Dispute => {
+                                            dispute_action(msg, &event, &my_keys, &client, &pool)
+                                                .await?;
+                                        }
+                                        Action::AdminCancel => {
+                                            admin_cancel_action(
+                                                msg, &event, &my_keys, &client, &pool, ln_client,
+                                            )
                                             .await?;
+                                        }
+                                        Action::AdminSettle => {
+                                            admin_settle_action(
+                                                msg, &event, &my_keys, &client, &pool, ln_client,
+                                            )
+                                            .await?;
+                                        }
+                                        Action::AdminAddSolver => {
+                                            admin_add_solver_action(
+                                                msg, &event, &my_keys, &client, &pool,
+                                            )
+                                            .await?;
+                                        }
+                                        Action::AdminTakeDispute => {
+                                            admin_take_dispute_action(
+                                                msg, &event, &my_keys, &client, &pool,
+                                            )
+                                            .await?;
+                                        }
+                                        _ => todo!(),
                                     }
-                                    Action::AdminCancel => {
-                                        admin_cancel_action(
-                                            msg, &event, &my_keys, &client, &pool, ln_client,
-                                        )
-                                        .await?;
-                                    }
-                                    Action::AdminSettle => {
-                                        admin_settle_action(
-                                            msg, &event, &my_keys, &client, &pool, ln_client,
-                                        )
-                                        .await?;
-                                    }
-                                    Action::AdminAddSolver => {
-                                        admin_add_solver_action(
-                                            msg, &event, &my_keys, &client, &pool,
-                                        )
-                                        .await?;
-                                    }
-                                    Action::AdminTakeDispute => {
-                                        admin_take_dispute_action(
-                                            msg, &event, &my_keys, &client, &pool,
-                                        )
-                                        .await?;
-                                    }
-                                    _ => todo!(),
                                 }
                             }
                         }
-                    }
-                };
+                    };
+                }
             }
         }
     }
diff --git a/src/app/add_invoice.rs b/src/app/add_invoice.rs
index 1043f86..1746ada 100644
--- a/src/app/add_invoice.rs
+++ b/src/app/add_invoice.rs
@@ -5,8 +5,9 @@ use crate::util::{send_dm, show_hold_invoice};
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Action, Content, Message};
+use mostro_core::order::SmallOrder;
 use mostro_core::order::{Order, Status};
-use mostro_core::{order::SmallOrder, Action, Content, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -19,8 +20,9 @@ pub async fn add_invoice_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
+    let order_msg = msg.get_inner_message_kind();
     // Safe unwrap as we verified the message
-    let order_id = msg.order_id.unwrap();
+    let order_id = order_msg.id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -28,10 +30,9 @@ pub async fn add_invoice_action(
             return Ok(());
         }
     };
-
     let pr: String;
     // If a buyer sent me a lightning invoice we get it
-    if let Some(payment_request) = msg.get_payment_request() {
+    if let Some(payment_request) = order_msg.get_payment_request() {
         // Verify if invoice is valid
         match is_valid_invoice(
             &payment_request,
@@ -46,11 +47,9 @@ pub async fn add_invoice_action(
                 | MostroError::WrongAmountError
                 | MostroError::MinAmountError => {
                     // We create a Message
-                    let message = Message::new(
-                        0,
+                    let message = Message::cant_do(
                         Some(order.id),
                         None,
-                        Action::CantDo,
                         Some(Content::TextMessage(e.to_string())),
                     );
                     let message = message.as_json()?;
@@ -84,7 +83,7 @@ pub async fn add_invoice_action(
     // Only the buyer can add an invoice
     if buyer_pubkey != event.pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json().unwrap();
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -95,11 +94,9 @@ pub async fn add_invoice_action(
         Status::WaitingBuyerInvoice => {}
         _ => {
             // We create a Message
-            let message = Message::new(
-                0,
+            let message = Message::cant_do(
                 Some(order.id),
                 None,
-                Action::CantDo,
                 Some(Content::TextMessage(format!(
                     "Order Id {order_id} status must be WaitingBuyerInvoice!"
                 ))),
@@ -116,7 +113,9 @@ pub async fn add_invoice_action(
     if order.preimage.is_some() {
         // We send this data related to the order to the parties
         let order_data = SmallOrder::new(
-            order.id,
+            Some(order.id),
+            None,
+            None,
             order.amount,
             order.fiat_code.clone(),
             order.fiat_amount,
@@ -124,25 +123,25 @@ pub async fn add_invoice_action(
             order.premium,
             order.buyer_pubkey.as_ref().cloned(),
             order.seller_pubkey.as_ref().cloned(),
+            None,
+            None,
         );
         // We send a confirmation message to seller
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::BuyerTookOrder,
-            Some(Content::SmallOrder(order_data.clone())),
+            Some(Content::Order(order_data.clone())),
         );
         let message = message.as_json().unwrap();
 
         send_dm(client, my_keys, &seller_pubkey, message).await?;
         // We send a message to buyer saying seller paid
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::HoldInvoicePaymentAccepted,
-            Some(Content::SmallOrder(order_data)),
+            Some(Content::Order(order_data)),
         );
         let message = message.as_json().unwrap();
         send_dm(client, my_keys, &buyer_pubkey, message)
diff --git a/src/app/admin_add_solver.rs b/src/app/admin_add_solver.rs
index 5ab3af2..b4339cd 100644
--- a/src/app/admin_add_solver.rs
+++ b/src/app/admin_add_solver.rs
@@ -3,8 +3,8 @@ use crate::util::send_dm;
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Action, Content, Message};
 use mostro_core::user::User;
-use mostro_core::{Action, Content, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 
@@ -15,7 +15,8 @@ pub async fn admin_add_solver_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
-    let content = if let Some(content) = msg.content {
+    let inner_message = msg.get_inner_message_kind();
+    let content = if let Some(content) = &inner_message.content {
         content
     } else {
         error!("No pubkey found!");
@@ -32,17 +33,17 @@ pub async fn admin_add_solver_action(
     // Check if the pubkey is Mostro
     if event.pubkey.to_bech32()? != mostro_pubkey {
         // We create a Message
-        let message = Message::new(0, None, None, Action::CantDo, None);
+        let message = Message::cant_do(None, None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
         return Ok(());
     }
-    let user = User::new(npubkey, 0, 1, 0, 0);
+    let user = User::new(npubkey.to_string(), 0, 1, 0, 0);
     add_user(&user, pool).await?;
 
     // We create a Message for admin
-    let message = Message::new(0, None, None, Action::AdminAddSolver, None);
+    let message = Message::new_dispute(None, None, Action::AdminAddSolver, None);
     let message = message.as_json()?;
     // Send the message
     send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
diff --git a/src/app/admin_cancel.rs b/src/app/admin_cancel.rs
index 4ef39da..4c58da9 100644
--- a/src/app/admin_cancel.rs
+++ b/src/app/admin_cancel.rs
@@ -5,8 +5,8 @@ use crate::util::{send_dm, update_order_event};
 use anyhow::Result;
 use log::{error, info};
 use mostro_core::dispute::Status as DisputeStatus;
+use mostro_core::message::{Action, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -19,7 +19,7 @@ pub async fn admin_cancel_action(
     pool: &Pool<Sqlite>,
     ln_client: &mut LndConnector,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -31,7 +31,7 @@ pub async fn admin_cancel_action(
     // Check if the pubkey is Mostro
     if event.pubkey.to_bech32()? != mostro_pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -58,7 +58,7 @@ pub async fn admin_cancel_action(
     // and update on local database the status and new event id
     update_order_event(pool, client, my_keys, Status::CanceledByAdmin, &order, None).await?;
     // We create a Message
-    let message = Message::new(0, Some(order.id), None, Action::AdminCancel, None);
+    let message = Message::new_dispute(Some(order.id), None, Action::AdminCancel, None);
     let message = message.as_json()?;
     // Message to admin
     send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
diff --git a/src/app/admin_settle.rs b/src/app/admin_settle.rs
index c590317..d3505ce 100644
--- a/src/app/admin_settle.rs
+++ b/src/app/admin_settle.rs
@@ -5,8 +5,8 @@ use crate::util::{send_dm, settle_seller_hold_invoice};
 use anyhow::Result;
 use log::error;
 use mostro_core::dispute::Status as DisputeStatus;
+use mostro_core::message::{Action, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -19,7 +19,7 @@ pub async fn admin_settle_action(
     pool: &Pool<Sqlite>,
     ln_client: &mut LndConnector,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -43,7 +43,7 @@ pub async fn admin_settle_action(
         d.update(pool).await?;
     }
     // We create a Message
-    let message = Message::new(0, Some(order.id), None, Action::AdminSettle, None);
+    let message = Message::new_dispute(Some(order.id), None, Action::AdminSettle, None);
     let message = message.as_json()?;
     // Message to admin
     send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
diff --git a/src/app/admin_take_dispute.rs b/src/app/admin_take_dispute.rs
index c58588c..1d9a6bb 100644
--- a/src/app/admin_take_dispute.rs
+++ b/src/app/admin_take_dispute.rs
@@ -4,7 +4,7 @@ use crate::util::send_dm;
 use anyhow::Result;
 use log::error;
 use mostro_core::dispute::Status;
-use mostro_core::{Action, Content, Message};
+use mostro_core::message::{Action, Content, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 
@@ -15,7 +15,7 @@ pub async fn admin_take_dispute_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
-    let content = if let Some(content) = msg.content {
+    let content = if let Some(content) = msg.get_inner_message_kind().content.to_owned() {
         content
     } else {
         error!("No dispute id found!");
@@ -33,7 +33,7 @@ pub async fn admin_take_dispute_action(
     // TODO: solvers also can take disputes
     if event.pubkey.to_bech32()? != mostro_pubkey {
         // We create a Message
-        let message = Message::new(0, None, None, Action::CantDo, None);
+        let message = Message::cant_do(None, None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -43,7 +43,7 @@ pub async fn admin_take_dispute_action(
     take_dispute(pool, &Status::InProgress, dispute_id, &event.pubkey).await?;
 
     // We create a Message for admin
-    let message = Message::new(0, None, None, Action::AdminAddSolver, None);
+    let message = Message::new_dispute(None, None, Action::AdminAddSolver, None);
     let message = message.as_json()?;
     // Send the message
     send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
diff --git a/src/app/cancel.rs b/src/app/cancel.rs
index c834fc3..4458588 100644
--- a/src/app/cancel.rs
+++ b/src/app/cancel.rs
@@ -6,8 +6,8 @@ use crate::lightning::LndConnector;
 use crate::util::{send_dm, update_order_event};
 use anyhow::Result;
 use log::{error, info};
+use mostro_core::message::{Action, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -20,7 +20,7 @@ pub async fn cancel_action(
     pool: &Pool<Sqlite>,
     ln_client: &mut LndConnector,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let mut order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -33,7 +33,7 @@ pub async fn cancel_action(
         // Validates if this user is the order creator
         if user_pubkey != order.creator_pubkey {
             // We create a Message
-            let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+            let message = Message::cant_do(Some(order.id), None, None);
             let message = message.as_json()?;
             send_dm(client, my_keys, &event.pubkey, message).await?;
         } else {
@@ -41,7 +41,7 @@ pub async fn cancel_action(
             // and update on local database the status and new event id
             update_order_event(pool, client, my_keys, Status::Canceled, &order, None).await?;
             // We create a Message for cancel
-            let message = Message::new(0, Some(order.id), None, Action::Cancel, None);
+            let message = Message::new_order(Some(order.id), None, Action::Cancel, None);
             let message = message.as_json()?;
             send_dm(client, my_keys, &event.pubkey, message).await?;
         }
@@ -74,7 +74,7 @@ pub async fn cancel_action(
             Some(ref initiator_pubkey) => {
                 if initiator_pubkey == &user_pubkey {
                     // We create a Message
-                    let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+                    let message = Message::cant_do(Some(order.id), None, None);
                     let message = message.as_json()?;
                     send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -103,8 +103,7 @@ pub async fn cancel_action(
                     )
                     .await?;
                     // We create a Message for an accepted cooperative cancel and send it to both parties
-                    let message = Message::new(
-                        0,
+                    let message = Message::new_order(
                         Some(order.id),
                         None,
                         Action::CooperativeCancelAccepted,
@@ -122,8 +121,7 @@ pub async fn cancel_action(
                 // update db
                 init_cancel_order(pool, &order).await?;
                 // We create a Message to start a cooperative cancel and send it to both parties
-                let message = Message::new(
-                    0,
+                let message = Message::new_order(
                     Some(order.id),
                     None,
                     Action::CooperativeCancelInitiatedByYou,
@@ -131,8 +129,7 @@ pub async fn cancel_action(
                 );
                 let message = message.as_json()?;
                 send_dm(client, my_keys, &event.pubkey, message).await?;
-                let message = Message::new(
-                    0,
+                let message = Message::new_order(
                     Some(order.id),
                     None,
                     Action::CooperativeCancelInitiatedByPeer,
@@ -167,7 +164,7 @@ pub async fn cancel_add_invoice(
     let seller_pubkey = XOnlyPublicKey::from_bech32(seller_pubkey)?;
     if buyer_pubkey_bech32 != &user_pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -187,7 +184,7 @@ pub async fn cancel_add_invoice(
         )
         .await?;
         // We create a Message for cancel
-        let message = Message::new(0, Some(order.id), None, Action::Cancel, None);
+        let message = Message::new_order(Some(order.id), None, Action::Cancel, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
         send_dm(client, my_keys, &seller_pubkey, message).await?;
@@ -230,7 +227,7 @@ pub async fn cancel_pay_hold_invoice(
     let seller_pubkey = XOnlyPublicKey::from_bech32(seller_pubkey_bech32)?;
     if seller_pubkey_bech32 != &user_pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -242,7 +239,7 @@ pub async fn cancel_pay_hold_invoice(
         // and update on local database the status and new event id
         update_order_event(pool, client, my_keys, Status::Canceled, order, None).await?;
         // We create a Message for cancel
-        let message = Message::new(0, Some(order.id), None, Action::Cancel, None);
+        let message = Message::new_order(Some(order.id), None, Action::Cancel, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message.clone()).await?;
         send_dm(client, my_keys, &seller_pubkey, message).await?;
diff --git a/src/app/dispute.rs b/src/app/dispute.rs
index 597b78d..2bf5c45 100644
--- a/src/app/dispute.rs
+++ b/src/app/dispute.rs
@@ -6,8 +6,8 @@ use anyhow::Result;
 use log::error;
 use log::info;
 use mostro_core::dispute::Dispute;
+use mostro_core::message::{Action, Message};
 use mostro_core::order::Order;
-use mostro_core::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -19,7 +19,7 @@ pub async fn dispute_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -48,7 +48,7 @@ pub async fn dispute_action(
     // Add a check in case of no counterpart found
     if counterpart.is_empty() {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -71,19 +71,13 @@ pub async fn dispute_action(
     add_dispute(&dispute, pool).await?;
 
     // We create a Message for the initiator
-    let message = Message::new(0, Some(order.id), None, Action::DisputeInitiatedByYou, None);
+    let message = Message::new_dispute(Some(order.id), None, Action::DisputeInitiatedByYou, None);
     let message = message.as_json()?;
     let initiator_pubkey = XOnlyPublicKey::from_bech32(message_sender)?;
     send_dm(client, my_keys, &initiator_pubkey, message).await?;
 
     // We create a Message for the counterpart
-    let message = Message::new(
-        0,
-        Some(order.id),
-        None,
-        Action::DisputeInitiatedByPeer,
-        None,
-    );
+    let message = Message::new_dispute(Some(order.id), None, Action::DisputeInitiatedByPeer, None);
     let message = message.as_json()?;
     let counterpart_pubkey = XOnlyPublicKey::from_bech32(counterpart)?;
     send_dm(client, my_keys, &counterpart_pubkey, message).await?;
diff --git a/src/app/fiat_sent.rs b/src/app/fiat_sent.rs
index c5e9854..a7736ab 100644
--- a/src/app/fiat_sent.rs
+++ b/src/app/fiat_sent.rs
@@ -2,8 +2,8 @@ use crate::util::{send_dm, update_order_event};
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Action, Content, Message, Peer};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Content, Message, Peer};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -15,7 +15,7 @@ pub async fn fiat_sent_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -31,7 +31,7 @@ pub async fn fiat_sent_action(
     // Check if the pubkey is the buyer
     if Some(event.pubkey.to_bech32()?) != order.buyer_pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -52,8 +52,7 @@ pub async fn fiat_sent_action(
     let peer = Peer::new(event.pubkey.to_bech32()?);
 
     // We create a Message
-    let message = Message::new(
-        0,
+    let message = Message::new_order(
         Some(order.id),
         None,
         Action::FiatSent,
@@ -65,8 +64,7 @@ pub async fn fiat_sent_action(
     let peer = Peer::new(seller_pubkey.to_bech32()?);
 
     // We create a Message
-    let message = Message::new(
-        0,
+    let message = Message::new_order(
         Some(order.id),
         None,
         Action::FiatSent,
diff --git a/src/app/order.rs b/src/app/order.rs
index eea435c..98055e1 100644
--- a/src/app/order.rs
+++ b/src/app/order.rs
@@ -3,7 +3,7 @@ use crate::util::{get_market_quote, publish_order, send_dm};
 
 use anyhow::Result;
 use log::error;
-use mostro_core::{Action, Message};
+use mostro_core::message::Message;
 use nostr_sdk::prelude::ToBech32;
 use nostr_sdk::{Client, Event, Keys};
 use sqlx::{Pool, Sqlite};
@@ -15,7 +15,7 @@ pub async fn order_action(
     client: &Client,
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
-    if let Some(order) = msg.get_order() {
+    if let Some(order) = msg.get_inner_message_kind().get_order() {
         let mostro_settings = Settings::get_mostro();
         let quote = match get_market_quote(&order.fiat_amount, &order.fiat_code, &0).await {
             Ok(amount) => amount,
@@ -25,7 +25,7 @@ pub async fn order_action(
             }
         };
         if quote > mostro_settings.max_order_amount as i64 {
-            let message = Message::new(0, order.id, None, Action::CantDo, None);
+            let message = Message::cant_do(order.id, None, None);
             let message = message.as_json()?;
             send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -33,11 +33,11 @@ pub async fn order_action(
         }
 
         let initiator_ephemeral_pubkey = event.pubkey.to_bech32()?;
-        let master_pubkey = match msg.pubkey {
+        let master_pubkey = match msg.get_inner_message_kind().pubkey {
             Some(ref pk) => pk,
             None => {
                 // We create a Message
-                let message = Message::new(0, order.id, None, Action::CantDo, None);
+                let message = Message::cant_do(order.id, None, None);
                 let message = message.as_json()?;
                 send_dm(client, my_keys, &event.pubkey, message).await?;
 
diff --git a/src/app/rate_user.rs b/src/app/rate_user.rs
index 4cceabf..90d964a 100644
--- a/src/app/rate_user.rs
+++ b/src/app/rate_user.rs
@@ -2,9 +2,10 @@ use crate::util::{nostr_tags_to_tuple, send_dm, update_user_rating_event};
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Content, Message};
 use mostro_core::order::Order;
 use mostro_core::rating::Rating;
-use mostro_core::{Action, Content, Message, NOSTR_REPLACEABLE_EVENT_KIND};
+use mostro_core::NOSTR_REPLACEABLE_EVENT_KIND;
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -49,7 +50,7 @@ pub async fn update_user_reputation_action(
     pool: &Pool<Sqlite>,
     rate_list: Arc<Mutex<Vec<Event>>>,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -64,7 +65,7 @@ pub async fn update_user_reputation_action(
     let message_sender = event.pubkey.to_bech32()?;
 
     if order.status != "Success" {
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
         error!("Order Id {order_id} wrong status");
@@ -88,7 +89,7 @@ pub async fn update_user_reputation_action(
     // Add a check in case of no counterpart found
     if counterpart.is_empty() {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -111,7 +112,7 @@ pub async fn update_user_reputation_action(
     // Check if content of Peer is the same of counterpart
     let mut rating = 0_u8;
 
-    if let Content::RatingUser(v) = msg.content.unwrap() {
+    if let Content::RatingUser(v) = msg.get_inner_message_kind().content.to_owned().unwrap() {
         rating = v;
     }
 
@@ -159,7 +160,7 @@ pub async fn update_user_reputation_action(
         .await?;
 
         // Send confirmation message to user that rated
-        let message = Message::new(0, Some(order.id), None, Action::Received, None);
+        let message = Message::ack_rate_user(Some(order.id), None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
     }
diff --git a/src/app/release.rs b/src/app/release.rs
index 81b6303..2c75326 100644
--- a/src/app/release.rs
+++ b/src/app/release.rs
@@ -5,8 +5,8 @@ use crate::util::{rate_counterpart, send_dm, update_order_event};
 
 use anyhow::Result;
 use log::{error, info};
+use mostro_core::message::{Action, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -21,7 +21,7 @@ pub async fn release_action(
     pool: &Pool<Sqlite>,
     ln_client: &mut LndConnector,
 ) -> Result<()> {
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -40,8 +40,7 @@ pub async fn release_action(
 
     // We send a HoldInvoicePaymentSettled message to seller, the client should
     // indicate *funds released* message to seller
-    let message = Message::new(
-        0,
+    let message = Message::new_order(
         Some(order.id),
         None,
         Action::HoldInvoicePaymentSettled,
@@ -50,7 +49,7 @@ pub async fn release_action(
     let message = message.as_json()?;
     send_dm(client, my_keys, &seller_pubkey, message).await?;
     // We send a message to buyer indicating seller released funds
-    let message = Message::new(0, Some(order.id), None, Action::Release, None);
+    let message = Message::new_order(Some(order.id), None, Action::Release, None);
     let message = message.as_json()?;
     let buyer_pubkey = XOnlyPublicKey::from_bech32(order.buyer_pubkey.as_ref().unwrap())?;
     send_dm(client, my_keys, &buyer_pubkey, message).await?;
@@ -84,8 +83,12 @@ pub async fn release_action(
                             order.id, msg.payment.payment_hash
                         );
                         // Purchase completed message to buyer
-                        let message =
-                            Message::new(0, Some(order.id), None, Action::PurchaseCompleted, None);
+                        let message = Message::new_order(
+                            Some(order.id),
+                            None,
+                            Action::PurchaseCompleted,
+                            None,
+                        );
                         let message = message.as_json().unwrap();
                         send_dm(&client, &my_keys, &buyer_pubkey, message)
                             .await
diff --git a/src/app/take_buy.rs b/src/app/take_buy.rs
index 03e04b4..7bc897b 100644
--- a/src/app/take_buy.rs
+++ b/src/app/take_buy.rs
@@ -3,8 +3,8 @@ use crate::util::{get_market_quote, send_dm, show_hold_invoice};
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Action, Content, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Content, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -18,7 +18,7 @@ pub async fn take_buy_action(
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
     // Safe unwrap as we verified the message
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
     let mut order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
         None => {
@@ -27,9 +27,9 @@ pub async fn take_buy_action(
         }
     };
     // We check if the message have a pubkey
-    if msg.pubkey.is_none() {
+    if msg.get_inner_message_kind().pubkey.is_none() {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -57,20 +57,20 @@ pub async fn take_buy_action(
     };
     if buyer_pubkey == event.pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json().unwrap();
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
         return Ok(());
     }
     // We update the master pubkey
-    edit_master_seller_pubkey_order(pool, order.id, msg.pubkey).await?;
+    edit_master_seller_pubkey_order(pool, order.id, msg.get_inner_message_kind().pubkey.clone())
+        .await?;
     let seller_pubkey = event.pubkey;
     // Seller can take pending orders only
     if order_status != Status::Pending {
         // We create a Message
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::FiatSent,
diff --git a/src/app/take_sell.rs b/src/app/take_sell.rs
index aa06d1c..9bc9481 100644
--- a/src/app/take_sell.rs
+++ b/src/app/take_sell.rs
@@ -5,8 +5,8 @@ use crate::util::{send_dm, set_market_order_sats_amount, show_hold_invoice};
 
 use anyhow::Result;
 use log::error;
+use mostro_core::message::{Content, Message};
 use mostro_core::order::{Order, Status};
-use mostro_core::{Action, Content, Message};
 use nostr_sdk::prelude::*;
 use sqlx::{Pool, Sqlite};
 use sqlx_crud::Crud;
@@ -20,7 +20,7 @@ pub async fn take_sell_action(
     pool: &Pool<Sqlite>,
 ) -> Result<()> {
     // Safe unwrap as we verified the message
-    let order_id = msg.order_id.unwrap();
+    let order_id = msg.get_inner_message_kind().id.unwrap();
 
     let mut order = match Order::by_id(pool, order_id).await? {
         Some(order) => order,
@@ -34,9 +34,9 @@ pub async fn take_sell_action(
         return Ok(());
     }
     // We check if the message have a pubkey
-    if msg.pubkey.is_none() {
+    if msg.get_inner_message_kind().pubkey.is_none() {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
@@ -47,7 +47,7 @@ pub async fn take_sell_action(
     let pr: Option<String>;
     // If a buyer sent me a lightning invoice we look on db an order with
     // that order id and save the buyer pubkey and invoice fields
-    if let Some(payment_request) = msg.get_payment_request() {
+    if let Some(payment_request) = msg.get_inner_message_kind().get_payment_request() {
         let order_amount = if order.amount == 0 {
             None
         } else {
@@ -64,11 +64,9 @@ pub async fn take_sell_action(
                 | MostroError::WrongAmountError
                 | MostroError::MinAmountError => {
                     // We create a Message
-                    let message = Message::new(
-                        0,
+                    let message = Message::cant_do(
                         Some(order.id),
                         None,
-                        Action::CantDo,
                         Some(Content::TextMessage(e.to_string())),
                     );
                     let message = message.as_json()?;
@@ -114,14 +112,15 @@ pub async fn take_sell_action(
     };
     if seller_pubkey == event.pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;
 
         return Ok(());
     }
     // We update the master pubkey
-    edit_master_buyer_pubkey_order(pool, order.id, msg.pubkey.clone()).await?;
+    edit_master_buyer_pubkey_order(pool, order.id, msg.get_inner_message_kind().pubkey.clone())
+        .await?;
     let buyer_pubkey_bech32 = buyer_pubkey.to_bech32().ok();
     // Add buyer pubkey to order
     edit_buyer_pubkey_order(pool, order_id, buyer_pubkey_bech32).await?;
diff --git a/src/db.rs b/src/db.rs
index f8939eb..8041b9c 100644
--- a/src/db.rs
+++ b/src/db.rs
@@ -1,5 +1,5 @@
 use mostro_core::dispute::{Dispute, Status as DisputeStatus};
-use mostro_core::order::{Kind, NewOrder, Order, Status};
+use mostro_core::order::{Kind, Order, SmallOrder, Status};
 use mostro_core::user::User;
 use nostr_sdk::prelude::*;
 use sqlx::migrate::MigrateDatabase;
@@ -80,7 +80,7 @@ pub async fn add_dispute(dispute: &Dispute, pool: &SqlitePool) -> anyhow::Result
 
 pub async fn add_order(
     pool: &SqlitePool,
-    order: &NewOrder,
+    order: &SmallOrder,
     event_id: &str,
     initiator_pubkey: &str,
     master_pubkey: &str,
@@ -92,15 +92,15 @@ pub async fn add_order(
     let mut seller_pubkey: Option<String> = None;
     let mut master_seller_pubkey: Option<String> = None;
     let created_at = Timestamp::now();
-    if order.kind == Kind::Buy {
+    if order.kind == Some(Kind::Buy) {
         buyer_pubkey = Some(initiator_pubkey.to_string());
         master_buyer_pubkey = Some(master_pubkey.to_string());
     } else {
         seller_pubkey = Some(initiator_pubkey.to_string());
         master_seller_pubkey = Some(master_pubkey.to_string());
     }
-    let kind = order.kind.to_string();
-    let status = order.status.to_string();
+    let kind = order.kind.unwrap().to_string();
+    let status = order.status.unwrap().to_string();
     let price_from_api = order.amount == 0;
 
     let order = sqlx::query_as::<_, Order>(
diff --git a/src/flow.rs b/src/flow.rs
index 2b5fd47..7f661de 100644
--- a/src/flow.rs
+++ b/src/flow.rs
@@ -2,8 +2,8 @@ use crate::cli::settings::Settings;
 use crate::util::send_dm;
 
 use log::info;
-use mostro_core::order::Status;
-use mostro_core::{order::SmallOrder, Action, Content, Message};
+use mostro_core::message::{Action, Content, Message};
+use mostro_core::order::{SmallOrder, Status};
 use nostr_sdk::prelude::*;
 
 pub async fn hold_invoice_paid(hash: &str) {
@@ -28,7 +28,9 @@ pub async fn hold_invoice_paid(hash: &str) {
 
     // We send this data related to the order to the parties
     let mut order_data = SmallOrder::new(
-        order.id,
+        Some(order.id),
+        None,
+        None,
         order.amount,
         order.fiat_code.clone(),
         order.fiat_amount,
@@ -36,29 +38,29 @@ pub async fn hold_invoice_paid(hash: &str) {
         order.premium,
         master_buyer_pubkey,
         master_seller_pubkey,
+        None,
+        None,
     );
     let status;
 
     if order.buyer_invoice.is_some() {
         // We send a confirmation message to seller
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::BuyerTookOrder,
-            Some(Content::SmallOrder(order_data.clone())),
+            Some(Content::Order(order_data.clone())),
         );
         let message = message.as_json().unwrap();
         send_dm(&client, &my_keys, &seller_pubkey, message)
             .await
             .unwrap();
         // We send a message to buyer saying seller paid
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::HoldInvoicePaymentAccepted,
-            Some(Content::SmallOrder(order_data)),
+            Some(Content::Order(order_data)),
         );
         let message = message.as_json().unwrap();
         send_dm(&client, &my_keys, &buyer_pubkey, message)
@@ -73,19 +75,18 @@ pub async fn hold_invoice_paid(hash: &str) {
         order_data.amount = new_amount;
 
         // We ask to buyer for a new invoice
-        let message = Message::new(
-            0,
+        let message = Message::new_order(
             Some(order.id),
             None,
             Action::AddInvoice,
-            Some(Content::SmallOrder(order_data.clone())),
+            Some(Content::Order(order_data.clone())),
         );
         let message = message.as_json().unwrap();
         send_dm(&client, &my_keys, &buyer_pubkey, message)
             .await
             .unwrap();
         // We send a message to seller we are waiting for buyer invoice
-        let message = Message::new(0, Some(order.id), None, Action::WaitingBuyerInvoice, None);
+        let message = Message::new_order(Some(order.id), None, Action::WaitingBuyerInvoice, None);
         let message = message.as_json().unwrap();
         send_dm(&client, &my_keys, &seller_pubkey, message)
             .await
diff --git a/src/main.rs b/src/main.rs
index d53629c..7162d79 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -64,14 +64,14 @@ async fn main() -> Result<()> {
 
 #[cfg(test)]
 mod tests {
-    use mostro_core::order::NewOrder;
-    use mostro_core::Message;
+    use mostro_core::message::Message;
+    use mostro_core::order::SmallOrder;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     #[test]
     fn test_order_deserialize_serialize() {
         let sample_order = r#"{"kind":"Sell","status":"Pending","amount":100,"fiat_code":"XXX","fiat_amount":10,"payment_method":"belo","premium":1,"created_at":0}"#;
-        let order = NewOrder::from_json(sample_order).unwrap();
+        let order = SmallOrder::from_json(sample_order).unwrap();
         let json_order = order.as_json().unwrap();
         assert_eq!(sample_order, json_order);
     }
diff --git a/src/util.rs b/src/util.rs
index dea2e7a..6517e95 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -9,8 +9,8 @@ use crate::{db, flow};
 
 use anyhow::{Context, Result};
 use log::{error, info};
-use mostro_core::order::{Kind as OrderKind, NewOrder, Order, SmallOrder, Status};
-use mostro_core::{Action, Content, Message};
+use mostro_core::message::{Action, Content, Message};
+use mostro_core::order::{Kind as OrderKind, Order, SmallOrder, Status};
 use nostr_sdk::prelude::*;
 use sqlx::types::chrono::Utc;
 use sqlx::SqlitePool;
@@ -88,7 +88,7 @@ pub async fn publish_order(
     pool: &SqlitePool,
     client: &Client,
     keys: &Keys,
-    new_order: &NewOrder,
+    new_order: &SmallOrder,
     initiator_pubkey: &str,
     master_pubkey: &str,
     ack_pubkey: XOnlyPublicKey,
@@ -99,10 +99,10 @@ pub async fn publish_order(
     // We transform the order fields to tags to use in the event
     let tags = order_to_tags(&order);
     // Now we have the order id, we can create a new event adding this id to the Order object
-    let order = NewOrder::new(
+    let order = SmallOrder::new(
         Some(order_id),
-        OrderKind::from_str(&order.kind).unwrap(),
-        Status::Pending,
+        Some(OrderKind::from_str(&order.kind).unwrap()),
+        Some(Status::Pending),
         order.amount,
         order.fiat_code,
         order.fiat_amount,
@@ -111,7 +111,7 @@ pub async fn publish_order(
         None,
         None,
         None,
-        Utc::now().timestamp(),
+        Some(Utc::now().timestamp()),
     );
     let order_string = order.as_json().unwrap();
     info!("serialized order: {order_string}");
@@ -131,11 +131,10 @@ pub async fn publish_order(
     .await?;
 
     // Send message as ack with small order
-    let ack_message = Message::new(
-        0,
+    let ack_message = Message::new_order(
         order.id,
         None,
-        Action::Order,
+        Action::NewOrder,
         Some(Content::Order(order.clone())),
     );
     let ack_message = ack_message.as_json()?;
@@ -211,10 +210,10 @@ pub async fn update_order_event(
 ) -> Result<()> {
     let kind = OrderKind::from_str(&order.kind).unwrap();
     let amount = amount.unwrap_or(order.amount);
-    let publish_order = NewOrder::new(
+    let publish_order = SmallOrder::new(
         Some(order.id),
-        kind,
-        status,
+        Some(kind),
+        Some(status),
         amount,
         order.fiat_code.to_owned(),
         order.fiat_amount,
@@ -223,7 +222,7 @@ pub async fn update_order_event(
         None,
         None,
         None,
-        order.created_at,
+        Some(order.created_at),
     );
     let order_content = publish_order.as_json()?;
     let mut order = order.clone();
@@ -316,10 +315,9 @@ pub async fn show_hold_invoice(
     // We need to publish a new event with the new status
     update_order_event(pool, client, my_keys, Status::WaitingPayment, order, None).await?;
     let mut new_order = order.as_new_order();
-    new_order.status = Status::WaitingPayment;
+    new_order.status = Some(Status::WaitingPayment);
     // We create a Message to send the hold invoice to seller
-    let message = Message::new(
-        0,
+    let message = Message::new_order(
         Some(order.id),
         None,
         Action::PayInvoice,
@@ -333,7 +331,7 @@ pub async fn show_hold_invoice(
     // We send the hold invoice to the seller
     send_dm(client, my_keys, seller_pubkey, message).await?;
 
-    let message = Message::new(0, Some(order.id), None, Action::WaitingSellerToPay, None);
+    let message = Message::new_order(Some(order.id), None, Action::WaitingSellerToPay, None);
     let message = message.as_json()?;
 
     // We send a message to buyer to know that seller was requested to pay the invoice
@@ -395,7 +393,9 @@ pub async fn set_market_order_sats_amount(
 
     // We send this data related to the buyer
     let order_data = SmallOrder::new(
-        order.id,
+        Some(order.id),
+        None,
+        None,
         buyer_final_amount,
         order.fiat_code.clone(),
         order.fiat_amount,
@@ -403,14 +403,15 @@ pub async fn set_market_order_sats_amount(
         order.premium,
         None,
         None,
+        None,
+        None,
     );
     // We create a Message
-    let message = Message::new(
-        0,
+    let message = Message::new_order(
         Some(order.id),
         None,
         Action::AddInvoice,
-        Some(Content::SmallOrder(order_data)),
+        Some(Content::Order(order_data)),
     );
     let message = message.as_json()?;
 
@@ -437,15 +438,15 @@ pub async fn rate_counterpart(
     buyer_pubkey: &XOnlyPublicKey,
     seller_pubkey: &XOnlyPublicKey,
     my_keys: &Keys,
-    order: NewOrder,
+    order: SmallOrder,
 ) -> Result<()> {
     // Send dm to counterparts
     // to buyer
-    let message_to_buyer = Message::new(0, order.id, None, Action::RateUser, None);
+    let message_to_buyer = Message::new_rate_user(order.id, None, None);
     let message_to_buyer = message_to_buyer.as_json().unwrap();
     send_dm(client, my_keys, buyer_pubkey, message_to_buyer).await?;
     // to seller
-    let message_to_seller = Message::new(0, order.id, None, Action::RateUser, None);
+    let message_to_seller = Message::new_rate_user(order.id, None, None);
     let message_to_seller = message_to_seller.as_json().unwrap();
     send_dm(client, my_keys, seller_pubkey, message_to_seller).await?;
 
@@ -474,7 +475,7 @@ pub async fn settle_seller_hold_invoice(
     // Check if the pubkey is right
     if event.pubkey.to_bech32()? != pubkey {
         // We create a Message
-        let message = Message::new(0, Some(order.id), None, Action::CantDo, None);
+        let message = Message::cant_do(Some(order.id), None, None);
         let message = message.as_json()?;
         send_dm(client, my_keys, &event.pubkey, message).await?;