diff --git a/crates/fiber-lib/src/fiber/amp.rs b/crates/fiber-lib/src/fiber/amp.rs
new file mode 100644
index 000000000..942d8a9a7
--- /dev/null
+++ b/crates/fiber-lib/src/fiber/amp.rs
@@ -0,0 +1,153 @@
+use crate::fiber::{hash_algorithm::HashAlgorithm, types::Hash256};
+use bitcoin::hashes::{sha256::Hash as Sha256, Hash as _};
+use rand::RngCore;
+use serde::{Deserialize, Serialize};
+
+/// AmpSecret represents an n-of-n sharing of a secret 32-byte value.
+/// The secret can be recovered by XORing all n shares together.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AmpSecret([u8; 32]);
+
+impl AmpSecret {
+    /// Create a new AmpSecret from a 32-byte array
+    pub fn new(bytes: [u8; 32]) -> Self {
+        Self(bytes)
+    }
+
+    /// Create a zero AmpSecret
+    pub fn zero() -> Self {
+        Self([0u8; 32])
+    }
+
+    /// Generate a random AmpSecret
+    pub fn random() -> Self {
+        let mut rng = rand::thread_rng();
+        let mut bytes = [0u8; 32];
+        rng.fill_bytes(&mut bytes);
+        Self(bytes)
+    }
+
+    /// XOR this AmpSecret with another AmpSecret, storing the result in self
+    pub fn xor_assign(&mut self, other: &AmpSecret) {
+        for (a, b) in self.0.iter_mut().zip(other.0.iter()) {
+            *a ^= b;
+        }
+    }
+
+    /// XOR two shares and return the result
+    pub fn xor(&self, other: &AmpSecret) -> AmpSecret {
+        let mut result = *self;
+        result.xor_assign(other);
+        result
+    }
+
+    /// Get the underlying bytes
+    pub fn as_bytes(&self) -> &[u8; 32] {
+        &self.0
+    }
+
+    /// Convert to bytes
+    pub fn to_bytes(self) -> [u8; 32] {
+        self.0
+    }
+
+    /// generate a random AmpSecret sequence
+    pub fn gen_random_sequence(root: AmpSecret, n: u16) -> Vec<AmpSecret> {
+        let mut shares: Vec<AmpSecret> = (0..n - 1).map(|_| AmpSecret::random()).collect();
+
+        let mut final_secret = root;
+        for share in &shares {
+            final_secret.xor_assign(share);
+        }
+        shares.push(final_secret);
+        shares
+    }
+}
+
+impl From<[u8; 32]> for AmpSecret {
+    fn from(bytes: [u8; 32]) -> Self {
+        Self(bytes)
+    }
+}
+
+impl AsRef<[u8]> for AmpSecret {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// AmpChildDesc is the meta data for a child payment derived from the root seed.
+/// It contains the index of the child and the share used in the derivation.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AmpChildDesc {
+    pub index: u16,
+    pub secret: AmpSecret,
+}
+
+impl AmpChildDesc {
+    pub fn new(index: u16, secret: AmpSecret) -> Self {
+        Self { index, secret }
+    }
+}
+
+/// Child is a payment hash and preimage pair derived from the root seed and ChildDesc.
+/// In addition to the derived values, a Child carries all information required in
+/// the derivation apart from the root seed (unless n=1).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct AmpChild {
+    /// Preimage is the child payment preimage that can be used to settle the HTLC
+    pub preimage: Hash256,
+
+    /// Hash is the child payment hash that to be carried by the HTLC
+    pub hash: Hash256,
+}
+
+impl AmpChild {
+    pub fn new(preimage: Hash256, hash: Hash256) -> Self {
+        Self { preimage, hash }
+    }
+
+    /// DeriveChild computes the child preimage and child hash for a given (root, share, index) tuple.
+    /// The derivation is defined as:
+    ///   child_preimage = SHA256(root || share || be16(index))
+    ///   child_hash = SHA256(child_preimage)
+    pub fn derive_child(
+        root: AmpSecret,
+        desc: AmpChildDesc,
+        hash_algorithm: HashAlgorithm,
+    ) -> AmpChild {
+        let index_bytes = desc.index.to_be_bytes();
+
+        // Compute child_preimage as SHA256(root || share || child_index)
+        let mut preimage_data = Vec::with_capacity(32 + 32 + 2);
+        preimage_data.extend_from_slice(root.as_bytes());
+        preimage_data.extend_from_slice(desc.secret.as_bytes());
+        preimage_data.extend_from_slice(&index_bytes);
+
+        let preimage_hash = Sha256::hash(&preimage_data);
+        let preimage: Hash256 = preimage_hash.to_byte_array().into();
+
+        // this is the payment hash for HTLC
+        let hash: Hash256 = hash_algorithm.hash(preimage.as_ref()).into();
+        AmpChild::new(preimage, hash)
+    }
+
+    /// ReconstructChildren derives the set of children hashes and preimages from the
+    /// provided descriptors.
+    pub fn reconstruct_amp_children(
+        child_descs: &[AmpChildDesc],
+        hash_algorithm: HashAlgorithm,
+    ) -> Vec<AmpChild> {
+        // Recompute the root by XORing the provided shares
+        let mut root = AmpSecret::zero();
+        for desc in child_descs {
+            root.xor_assign(&desc.secret);
+        }
+
+        // With the root computed, derive the child hashes and preimages
+        child_descs
+            .iter()
+            .map(|data| Self::derive_child(root, data.clone(), hash_algorithm))
+            .collect()
+    }
+}
diff --git a/crates/fiber-lib/src/fiber/builtin_records.rs b/crates/fiber-lib/src/fiber/builtin_records.rs
new file mode 100644
index 000000000..d2e332ed7
--- /dev/null
+++ b/crates/fiber-lib/src/fiber/builtin_records.rs
@@ -0,0 +1,124 @@
+use serde::{Deserialize, Serialize};
+
+use crate::fiber::{
+    amp::{AmpChildDesc, AmpSecret},
+    network::USER_CUSTOM_RECORDS_MAX_INDEX,
+    types::Hash256,
+    PaymentCustomRecords,
+};
+
+#[derive(Eq, PartialEq, Debug)]
+/// Bolt04 basic MPP payment data record
+pub struct BasicMppPaymentData {
+    pub payment_secret: Hash256,
+    pub total_amount: u128,
+}
+
+impl BasicMppPaymentData {
+    // record type for payment data record in bolt04
+    // custom records key from 65536 is reserved for internal usage
+    pub const CUSTOM_RECORD_KEY: u32 = USER_CUSTOM_RECORDS_MAX_INDEX + 1;
+
+    pub fn new(payment_secret: Hash256, total_amount: u128) -> Self {
+        Self {
+            payment_secret,
+            total_amount,
+        }
+    }
+
+    fn to_vec(&self) -> Vec<u8> {
+        let mut vec = Vec::new();
+        vec.extend_from_slice(self.payment_secret.as_ref());
+        vec.extend_from_slice(&self.total_amount.to_le_bytes());
+        vec
+    }
+
+    pub fn write(&self, custom_records: &mut PaymentCustomRecords) {
+        custom_records
+            .data
+            .insert(Self::CUSTOM_RECORD_KEY, self.to_vec());
+    }
+
+    pub fn read(custom_records: &PaymentCustomRecords) -> Option<Self> {
+        custom_records
+            .data
+            .get(&Self::CUSTOM_RECORD_KEY)
+            .and_then(|data| {
+                if data.len() != 32 + 16 {
+                    return None;
+                }
+                let secret: [u8; 32] = data[..32].try_into().unwrap();
+                let payment_secret = Hash256::from(secret);
+                let total_amount = u128::from_le_bytes(data[32..].try_into().unwrap());
+                Some(Self::new(payment_secret, total_amount))
+            })
+    }
+}
+
+#[derive(Clone, Eq, PartialEq, Debug, Serialize, Deserialize)]
+pub struct AmpPaymentData {
+    pub total_amp_count: u16,
+    pub payment_hash: Hash256,
+    pub child_desc: AmpChildDesc,
+    pub total_amount: u128,
+}
+
+impl AmpPaymentData {
+    pub const CUSTOM_RECORD_KEY: u32 = USER_CUSTOM_RECORDS_MAX_INDEX + 2;
+
+    pub fn new(
+        payment_hash: Hash256,
+        total_amp_count: u16,
+        child_desc: AmpChildDesc,
+        total_amount: u128,
+    ) -> Self {
+        Self {
+            payment_hash,
+            total_amp_count,
+            child_desc,
+            total_amount,
+        }
+    }
+
+    fn to_vec(&self) -> Vec<u8> {
+        let mut vec = Vec::new();
+        vec.extend_from_slice(self.payment_hash.as_ref());
+        vec.extend_from_slice(&self.total_amp_count.to_le_bytes());
+        vec.extend_from_slice(&self.child_desc.index.to_le_bytes());
+        vec.extend_from_slice(self.child_desc.secret.as_bytes());
+        vec.extend_from_slice(&self.total_amount.to_le_bytes());
+        vec
+    }
+
+    pub fn index(&self) -> u16 {
+        self.child_desc.index
+    }
+
+    pub fn write(&self, custom_records: &mut PaymentCustomRecords) {
+        custom_records
+            .data
+            .insert(Self::CUSTOM_RECORD_KEY, self.to_vec());
+    }
+
+    pub fn read(custom_records: &PaymentCustomRecords) -> Option<Self> {
+        custom_records
+            .data
+            .get(&Self::CUSTOM_RECORD_KEY)
+            .and_then(|data| {
+                if data.len() != 32 + 4 + 32 + 16 {
+                    return None;
+                }
+                let parent_hash: [u8; 32] = data[..32].try_into().unwrap();
+                let total_amp_count = u16::from_le_bytes(data[32..34].try_into().unwrap());
+                let index = u16::from_le_bytes(data[34..36].try_into().unwrap());
+                let secret = AmpSecret::new(data[36..68].try_into().unwrap());
+                let total_amount = u128::from_le_bytes(data[68..].try_into().unwrap());
+                Some(Self::new(
+                    Hash256::from(parent_hash),
+                    total_amp_count,
+                    AmpChildDesc::new(index, secret),
+                    total_amount,
+                ))
+            })
+    }
+}
diff --git a/crates/fiber-lib/src/fiber/channel.rs b/crates/fiber-lib/src/fiber/channel.rs
index 0fbf3a859..dfb2b3d73 100644
--- a/crates/fiber-lib/src/fiber/channel.rs
+++ b/crates/fiber-lib/src/fiber/channel.rs
@@ -5,6 +5,7 @@ use super::{
     gossip::SOFT_BROADCAST_MESSAGES_CONSIDERED_STALE_DURATION, graph::ChannelUpdateInfo,
     types::ForwardTlcResult,
 };
+use crate::fiber::builtin_records::AmpPaymentData;
 use crate::fiber::config::MILLI_SECONDS_PER_EPOCH;
 use crate::fiber::fee::{check_open_channel_parameters, check_tlc_delta_with_epochs};
 #[cfg(any(debug_assertions, feature = "bench"))]
@@ -904,6 +905,19 @@ where
         tlc_id: TLCId,
     ) {
         let tlc_info = state.get_received_tlc(tlc_id).expect("expect tlc").clone();
+        let parent_payment_hash = tlc_info
+            .parent_payment_hash
+            .unwrap_or(tlc_info.payment_hash);
+
+        // MPP or AMP
+        if tlc_info.total_amount.is_some() {
+            // add to pending settlement tlc set
+            // the tlc set will be settled by network actor
+            state
+                .pending_notify_settle_tlcs
+                .push((parent_payment_hash, tlc_info.id(), true));
+            return;
+        }
 
         let Some(preimage) = self.store.get_preimage(&tlc_info.payment_hash) else {
             return;
@@ -922,13 +936,13 @@ where
                 CkbInvoiceStatus::Expired => {
                     remove_reason = RemoveTlcReason::RemoveTlcFail(TlcErrPacket::new(
                         TlcErr::new(TlcErrorCode::InvoiceExpired),
-                        &tlc.shared_secret,
+                        &tlc_info.shared_secret,
                     ));
                 }
                 CkbInvoiceStatus::Cancelled => {
                     remove_reason = RemoveTlcReason::RemoveTlcFail(TlcErrPacket::new(
                         TlcErr::new(TlcErrorCode::InvoiceCancelled),
-                        &tlc.shared_secret,
+                        &tlc_info.shared_secret,
                     ));
                 }
                 CkbInvoiceStatus::Paid => {
@@ -937,28 +951,17 @@ where
                     error!("invoice already paid, ignore");
                     return;
                 }
-                _ if invoice.allow_mpp() => {
-                    // add to pending settlement tlc set
-                    // the tlc set will be settled by network actor
-                    state
-                        .pending_notify_settle_tlcs
-                        .push((tlc.payment_hash, tlc.id(), true));
-
-                    // just return, the tlc set will be settled by network actor
-                    return;
-                }
                 _ => {
                     // single path payment
                     if !is_invoice_fulfilled(invoice, std::slice::from_ref(&tlc)) {
                         remove_reason = RemoveTlcReason::RemoveTlcFail(TlcErrPacket::new(
                             TlcErr::new(TlcErrorCode::IncorrectOrUnknownPaymentDetails),
-                            &tlc.shared_secret,
+                            &tlc_info.shared_secret,
                         ));
                     }
                 }
             }
         }
-
         // remove tlc
         if matches!(remove_reason, RemoveTlcReason::RemoveTlcFulfill(_)) && invoice.is_some() {
             state
@@ -1034,6 +1037,7 @@ where
     ) -> ProcessingChannelResult {
         let payment_hash = add_tlc.payment_hash;
         let forward_amount = peeled_onion_packet.current.amount;
+        let channel_id = state.get_id();
 
         let tlc = state
             .tlc_state
@@ -1050,7 +1054,16 @@ where
                 return Err(ProcessingChannelError::IncorrectFinalTlcExpiry);
             }
 
-            let invoice = self.store.get_invoice(&payment_hash);
+            let basic_mpp_payment_data = peeled_onion_packet.basic_mpp_custom_records();
+            let atomic_mpp_payment_data = peeled_onion_packet.atomic_mpp_custom_records();
+            let is_atomic_mpp = atomic_mpp_payment_data.is_some();
+
+            let parent_payment_hash = atomic_mpp_payment_data
+                .as_ref()
+                .map(|a| a.payment_hash)
+                .unwrap_or(payment_hash);
+
+            let invoice = self.store.get_invoice(&parent_payment_hash);
             if let Some(ref invoice) = invoice {
                 let invoice_status = self.get_invoice_status(invoice);
                 if !matches!(invoice_status, CkbInvoiceStatus::Open) {
@@ -1066,8 +1079,8 @@ where
             tlc.is_last = true;
 
             // extract MPP total payment fields from onion packet
-            match (&invoice, peeled_onion_packet.mpp_custom_records()) {
-                (Some(invoice), Some(record)) => {
+            match (&invoice, basic_mpp_payment_data, atomic_mpp_payment_data) {
+                (Some(invoice), Some(record), None) => {
                     if record.total_amount < invoice.amount.unwrap_or_default() {
                         error!(
                             "total amount is less than invoice amount: {:?}",
@@ -1092,8 +1105,24 @@ where
                     tlc.payment_secret = Some(record.payment_secret);
                     tlc.total_amount = Some(record.total_amount);
                 }
-                (Some(invoice), None) => {
-                    if invoice.allow_mpp() {
+                (_, None, Some(record)) => {
+                    tlc.total_amount = Some(record.total_amount);
+                    tlc.parent_payment_hash = Some(parent_payment_hash);
+                    // now save amp_record with parent payment_hash as key
+                    self.store.insert_atomic_mpp_payment_data(
+                        parent_payment_hash,
+                        channel_id,
+                        tlc.tlc_id.into(),
+                        record.clone(),
+                    );
+                }
+                (Some(invoice), _, None) if invoice.atomic_mpp() => {
+                    return Err(ProcessingChannelError::FinalIncorrectMPPInfo(
+                        "invoice is atomic mpp but no MPP records in onion packet".to_string(),
+                    ));
+                }
+                (Some(invoice), None, _) => {
+                    if invoice.basic_mpp() {
                         // FIXME: whether we allow MPP without MPP records in onion packet?
                         // currently we allow it pay with enough amount
                         // TODO: add a unit test of using single path payment pay MPP invoice successfully
@@ -1107,7 +1136,7 @@ where
                         return Err(ProcessingChannelError::FinalIncorrectHTLCAmount);
                     }
                 }
-                (None, Some(_record)) => {
+                (None, Some(_), _) => {
                     error!("invoice not found for MPP payment: {:?}", payment_hash);
                     return Err(ProcessingChannelError::FinalIncorrectMPPInfo(
                         "invoice not found".to_string(),
@@ -1143,6 +1172,8 @@ where
 
                 // Don't call self.store_preimage here, because it will reveal the preimage to watchtower.
                 self.store.insert_preimage(payment_hash, preimage);
+            } else if is_atomic_mpp {
+                // atomic mpp don't have preimage
             } else if let Some(invoice) = invoice {
                 // The TLC should be held until the invoice is expired or the TLC itself is
                 // expired.
@@ -3010,6 +3041,8 @@ pub struct TlcInfo {
     pub total_amount: Option<u128>,
     /// bolt04 payment secret, only exists for last hop in multi-path payment
     pub payment_secret: Option<Hash256>,
+    /// atomic parent payment_hash
+    pub parent_payment_hash: Option<Hash256>,
     /// The attempt id associate with the tlc, only on outbound tlc
     /// only exists for first hop in multi-path payment
     pub attempt_id: Option<u64>,
@@ -5795,6 +5828,13 @@ impl ChannelActorState {
         if is_sent {
             // local peer can not sent more tlc amount than they have
             let pending_sent_amount = self.get_offered_tlc_balance();
+            debug!(
+                "add_amount: {}, to_local_amount:{} - pending_sent_amount:{} = {}",
+                add_amount,
+                self.to_local_amount,
+                pending_sent_amount,
+                self.to_local_amount.saturating_sub(pending_sent_amount)
+            );
             if add_amount > self.to_local_amount.saturating_sub(pending_sent_amount) {
                 return Err(ProcessingChannelError::TlcAmountExceedLimit);
             }
@@ -5814,6 +5854,13 @@ impl ChannelActorState {
         } else {
             // remote peer can not sent more tlc amount than they have
             let pending_recv_amount = self.get_received_tlc_balance();
+            debug!(
+                "remote_amount: {}, to_remote_amount:{} - pending_recv_amount:{} = {}",
+                add_amount,
+                self.to_remote_amount,
+                pending_recv_amount,
+                self.to_local_amount.saturating_sub(pending_recv_amount)
+            );
             if add_amount > self.to_remote_amount.saturating_sub(pending_recv_amount) {
                 return Err(ProcessingChannelError::TlcAmountExceedLimit);
             }
@@ -5849,6 +5896,7 @@ impl ChannelActorState {
             attempt_id: command.attempt_id,
             amount: command.amount,
             payment_hash: command.payment_hash,
+            parent_payment_hash: None,
             expiry: command.expiry,
             hash_algorithm: command.hash_algorithm,
             created_at: self.get_current_commitment_numbers(),
@@ -5876,6 +5924,7 @@ impl ChannelActorState {
             channel_id: self.get_id(),
             amount: message.amount,
             payment_hash: message.payment_hash,
+            parent_payment_hash: None,
             attempt_id: None,
             expiry: message.expiry,
             hash_algorithm: message.hash_algorithm,
@@ -7602,6 +7651,17 @@ pub trait ChannelActorStateStore {
     fn remove_payment_hold_tlc(&self, payment_hash: &Hash256, channel_id: &Hash256, tlc_id: u64);
     fn get_payment_hold_tlcs(&self, payment_hash: Hash256) -> Vec<HoldTlc>;
     fn get_node_hold_tlcs(&self) -> HashMap<Hash256, Vec<HoldTlc>>;
+    fn insert_atomic_mpp_payment_data(
+        &self,
+        payment_hash: Hash256,
+        channel_id: Hash256,
+        tlc_id: u64,
+        payment_data: AmpPaymentData,
+    );
+    fn get_atomic_mpp_payment_data(
+        &self,
+        payment_hash: &Hash256,
+    ) -> Vec<((Hash256, u64), AmpPaymentData)>;
 }
 
 /// A wrapper on CommitmentTransaction that has a partial signature along with
diff --git a/crates/fiber-lib/src/fiber/features.rs b/crates/fiber-lib/src/fiber/features.rs
index d61bdd96a..5e69d1e73 100644
--- a/crates/fiber-lib/src/fiber/features.rs
+++ b/crates/fiber-lib/src/fiber/features.rs
@@ -74,6 +74,7 @@ pub mod feature_bits {
     declare_feature_bits_and_methods! {
         GOSSIP_QUERIES, 1;
         BASIC_MPP, 3;
+        ATOMIC_MPP, 5;
         // more features, please note that base bit must be defined as increasing odd numbers
     }
 }
@@ -88,6 +89,7 @@ impl Default for FeatureVector {
         let mut feature = Self::new();
         feature.set_gossip_queries_required();
         feature.set_basic_mpp_required();
+        feature.set_atomic_mpp_required();
 
         // set other default features here
         // ...
diff --git a/crates/fiber-lib/src/fiber/graph.rs b/crates/fiber-lib/src/fiber/graph.rs
index 86cf72f5b..572541037 100644
--- a/crates/fiber-lib/src/fiber/graph.rs
+++ b/crates/fiber-lib/src/fiber/graph.rs
@@ -2088,4 +2088,9 @@ pub trait NetworkGraphStateStore {
     fn get_attempts(&self, payment_hash: Hash256) -> Vec<Attempt>;
     fn delete_attempts(&self, payment_hash: Hash256);
     fn get_attempts_with_statuses(&self, status: &[AttemptStatus]) -> Vec<Attempt>;
+    fn get_payment_hash_with_attempt_hash(
+        &self,
+        attempt_hash: Hash256,
+        attempt_id: u64,
+    ) -> Option<Hash256>;
 }
diff --git a/crates/fiber-lib/src/fiber/mod.rs b/crates/fiber-lib/src/fiber/mod.rs
index 1a1c59605..c0ee70d25 100644
--- a/crates/fiber-lib/src/fiber/mod.rs
+++ b/crates/fiber-lib/src/fiber/mod.rs
@@ -1,3 +1,5 @@
+pub mod amp;
+pub mod builtin_records;
 pub mod channel;
 pub mod config;
 pub mod features;
diff --git a/crates/fiber-lib/src/fiber/network.rs b/crates/fiber-lib/src/fiber/network.rs
index 6e39ee7d9..821691dbc 100644
--- a/crates/fiber-lib/src/fiber/network.rs
+++ b/crates/fiber-lib/src/fiber/network.rs
@@ -62,9 +62,9 @@ use super::gossip::{GossipActorMessage, GossipMessageStore, GossipMessageUpdates
 use super::graph::{NetworkGraph, NetworkGraphStateStore, OwnedChannelUpdateEvent, RouterHop};
 use super::key::blake2b_hash_with_salt;
 use super::types::{
-    BasicMppPaymentData, BroadcastMessageWithTimestamp, EcdsaSignature, FiberMessage,
-    ForwardTlcResult, GossipMessage, Hash256, Init, NodeAnnouncement, OpenChannel, Privkey, Pubkey,
-    RemoveTlcFulfill, RemoveTlcReason, TlcErr, TlcErrData, TlcErrorCode,
+    BroadcastMessageWithTimestamp, EcdsaSignature, FiberMessage, ForwardTlcResult, GossipMessage,
+    Hash256, Init, NodeAnnouncement, OpenChannel, Privkey, Pubkey, RemoveTlcFulfill,
+    RemoveTlcReason, TlcErr, TlcErrData, TlcErrorCode,
 };
 use super::{
     FiberConfig, InFlightCkbTxActor, InFlightCkbTxActorArguments, InFlightCkbTxKind,
@@ -76,6 +76,8 @@ use crate::ckb::{
     CkbChainMessage, FundingError, FundingRequest, FundingTx, GetShutdownTxRequest,
     GetShutdownTxResponse,
 };
+use crate::fiber::amp::{AmpChild, AmpChildDesc, AmpSecret};
+use crate::fiber::builtin_records::{AmpPaymentData, BasicMppPaymentData};
 use crate::fiber::channel::{
     tlc_expiry_delay, AddTlcCommand, AddTlcResponse, ChannelActorState, ChannelEphemeralConfig,
     ChannelInitializationOperation, RetryableTlcOperation, ShutdownCommand, TxCollaborationCommand,
@@ -91,6 +93,7 @@ use crate::fiber::config::{
 use crate::fiber::fee::{check_open_channel_parameters, check_tlc_delta_with_epochs};
 use crate::fiber::gossip::{GossipConfig, GossipService, SubscribableGossipMessageStore};
 use crate::fiber::graph::GraphChannelStat;
+use crate::fiber::payment::MppMode;
 #[cfg(any(debug_assertions, test, feature = "bench"))]
 use crate::fiber::payment::SessionRoute;
 use crate::fiber::payment::{Attempt, AttemptStatus, PaymentSession, PaymentStatus};
@@ -102,8 +105,8 @@ use crate::fiber::KeyPair;
 use crate::invoice::{
     CkbInvoice, CkbInvoiceStatus, InvoiceError, InvoiceStore, PreimageStore, SettleInvoiceError,
 };
-use crate::utils::payment::is_invoice_fulfilled;
-use crate::{now_timestamp_as_millis_u64, unwrap_or_return, Error};
+use crate::utils::payment::{is_atomic_mpp_fulfilled, is_invoice_fulfilled};
+use crate::{gen_rand_sha256_hash, now_timestamp_as_millis_u64, unwrap_or_return, Error};
 
 pub const FIBER_PROTOCOL_ID: ProtocolId = ProtocolId::new(42);
 
@@ -401,6 +404,8 @@ pub struct SendPaymentCommand {
     pub max_parts: Option<u64>,
     // keysend payment, default is false
     pub keysend: Option<bool>,
+    // allow atomic mpp, default is false,
+    pub atomic_mpp: Option<bool>,
     // udt type script
     #[serde_as(as = "Option<EntityHex>")]
     pub udt_type_script: Option<Script>,
@@ -528,7 +533,8 @@ pub struct SendPaymentData {
     pub allow_self_payment: bool,
     pub hop_hints: Vec<HopHint>,
     pub router: Vec<RouterHop>,
-    pub allow_mpp: bool,
+    pub allow_basic_mpp: bool,
+    pub allow_atomic_mpp: bool,
     pub dry_run: bool,
     #[serde(skip)]
     pub channel_stats: GraphChannelStat,
@@ -543,7 +549,7 @@ impl SendPaymentData {
             .transpose()
             .map_err(|_| "invoice is invalid".to_string())?;
 
-        if let Some(invoice) = invoice.clone() {
+        if let Some(ref invoice) = invoice {
             if invoice.is_expired() {
                 return Err("invoice is expired".to_string());
             }
@@ -623,16 +629,20 @@ impl SendPaymentData {
         }
 
         let keysend = command.keysend.unwrap_or(false);
-        let (payment_hash, preimage) = if !keysend {
-            (
-                validate_field(
-                    command.payment_hash,
-                    invoice.as_ref().map(|i| *i.payment_hash()),
-                    "payment_hash",
-                )?,
-                None,
-            )
-        } else {
+        let atomic_mpp = command.atomic_mpp.unwrap_or(false);
+        let invoice_atomic_mpp = invoice.as_ref().map_or(atomic_mpp, |inv| inv.atomic_mpp());
+
+        if keysend && atomic_mpp {
+            return Err("keysend and AMP cannot be both true".to_string());
+        }
+        if invoice_atomic_mpp && !atomic_mpp {
+            return Err("It is a AMP invoice, need to set amp flag in SendPayment".to_string());
+        }
+        if atomic_mpp && !invoice_atomic_mpp {
+            return Err("AMP flag can not set for a non-AMP invoice".to_string());
+        }
+
+        let (payment_hash, preimage) = if keysend {
             if invoice.is_some() {
                 return Err("keysend payment should not have invoice".to_string());
             }
@@ -647,6 +657,17 @@ impl SendPaymentData {
             // use the default payment hash algorithm here for keysend payment
             let payment_hash: Hash256 = blake2b_256(preimage).into();
             (payment_hash, Some(preimage))
+        } else if atomic_mpp {
+            (gen_rand_sha256_hash(), None)
+        } else {
+            (
+                validate_field(
+                    command.payment_hash,
+                    invoice.as_ref().map(|i| *i.payment_hash()),
+                    "payment_hash",
+                )?,
+                None,
+            )
         };
 
         if udt_type_script.is_none() && amount >= u64::MAX as u128 {
@@ -670,21 +691,25 @@ impl SendPaymentData {
         }
 
         let hop_hints = command.hop_hints.unwrap_or_default();
+        let basic_mpp = invoice.as_ref().is_some_and(|inv| inv.basic_mpp());
+        let is_mpp_payment = basic_mpp || atomic_mpp;
+
+        if basic_mpp && atomic_mpp {
+            // invoice rpc already make sure this
+            return Err("basic_mpp and atomic_mpp cannot be both true".to_string());
+        }
 
-        let allow_mpp = invoice.as_ref().is_some_and(|inv| inv.allow_mpp());
         let payment_secret = invoice
             .as_ref()
             .and_then(|inv| inv.payment_secret().cloned());
-        if allow_mpp && payment_secret.is_none() {
-            return Err("payment secret is required for multi-path payment".to_string());
-        }
-        if allow_mpp
+
+        if is_mpp_payment
             && command
                 .max_parts
                 .is_some_and(|max_parts| max_parts <= 1 || max_parts > PAYMENT_MAX_PARTS_LIMIT)
         {
             return Err(format!(
-                "invalid max_parts, value should be in range [1, {}]",
+                "invalid max_parts, value should be in range [2, {}]",
                 PAYMENT_MAX_PARTS_LIMIT
             ));
         }
@@ -712,8 +737,13 @@ impl SendPaymentData {
         }
 
         let mut custom_records = command.custom_records;
-        // bolt04 write payment data record to custom records if payment secret is set
-        if let Some(payment_secret) = payment_secret {
+        if basic_mpp {
+            let Some(payment_secret) = payment_secret else {
+                // if basic mpp, payment secret is required
+                return Err("payment secret is required for multi-path payment".to_string());
+            };
+
+            // bolt04 write payment data record to custom records if payment secret is set
             let records = custom_records.get_or_insert_with(PaymentCustomRecords::default);
             BasicMppPaymentData::new(payment_secret, amount).write(records);
         }
@@ -734,7 +764,8 @@ impl SendPaymentData {
             custom_records,
             allow_self_payment: command.allow_self_payment,
             hop_hints,
-            allow_mpp,
+            allow_basic_mpp: basic_mpp,
+            allow_atomic_mpp: atomic_mpp,
             router: vec![],
             dry_run: command.dry_run,
             channel_stats: Default::default(),
@@ -747,7 +778,15 @@ impl SendPaymentData {
 
     pub fn allow_mpp(&self) -> bool {
         // only allow mpp if max_parts is greater than 1 and not keysend
-        self.allow_mpp && self.max_parts() > 1 && !self.keysend
+        (self.allow_basic_mpp || self.allow_atomic_mpp) && self.max_parts() > 1 && !self.keysend
+    }
+
+    pub fn is_basic_mpp(&self) -> bool {
+        self.allow_basic_mpp
+    }
+
+    pub fn is_atomic_mpp(&self) -> bool {
+        self.allow_atomic_mpp
     }
 }
 
@@ -1266,8 +1305,22 @@ where
                     &channel_id, &tx_hash, &peer_id
                 );
             }
-            NetworkActorEvent::TlcRemoveReceived(payment_hash, attempt_id, remove_tlc_reason) => {
+            NetworkActorEvent::TlcRemoveReceived(attempt_hash, attempt_id, remove_tlc_reason) => {
                 // When a node is restarted, RemoveTLC will also be resent if necessary
+                let payment_hash = attempt_id
+                    .and_then(|id| {
+                        self.store
+                            .get_payment_hash_with_attempt_hash(attempt_hash, id)
+                    })
+                    .or(Some(attempt_hash));
+                let Some(payment_hash) = payment_hash else {
+                    error!(
+                        "Failed to find payment hash for attempt_hash {:?}, attempt_id {:?}",
+                        attempt_hash, attempt_id
+                    );
+                    return Ok(());
+                };
+
                 self.on_remove_tlc_event(
                     myself.clone(),
                     state,
@@ -1295,7 +1348,9 @@ where
                     .resume_payment_session(myself, state, payment_hash, attempt_id)
                     .await;
             }
-            NetworkActorEvent::AddTlcResult(payment_hash, attempt_id, error_info, previous_tlc) => {
+            NetworkActorEvent::AddTlcResult(attempt_hash, attempt_id, error_info, previous_tlc) => {
+                let payment_hash =
+                    self.get_payment_hash_from_attempt_hash(attempt_hash, attempt_id);
                 self.on_add_tlc_result_event(
                     myself,
                     state,
@@ -1331,6 +1386,20 @@ where
         Ok(())
     }
 
+    pub fn get_payment_hash_from_attempt_hash(
+        &self,
+        attempt_hash: Hash256,
+        attempt_id: Option<u64>,
+    ) -> Hash256 {
+        if let Some(attempt_id) = attempt_id {
+            self.store
+                .get_payment_hash_with_attempt_hash(attempt_hash, attempt_id)
+                .unwrap_or(attempt_hash)
+        } else {
+            attempt_hash
+        }
+    }
+
     pub async fn handle_command(
         &self,
         myself: ActorRef<NetworkActorMessage>,
@@ -1444,9 +1513,9 @@ where
 
                 if num_outbound_peers >= state.min_outbound_peers {
                     debug!(
-                                "Already connected to {} outbound peers, wants a minimal of {} peers, skipping connecting to more peers",
-                                num_outbound_peers, state.min_outbound_peers
-                            );
+                        "Already connected to {} outbound peers, wants a minimal of {} peers, skipping connecting to more peers",
+                        num_outbound_peers, state.min_outbound_peers
+                    );
                     return Ok(());
                 }
 
@@ -1486,9 +1555,9 @@ where
                     debug!("Peer to connect: {:?}, {:?}", peer_id, addresses);
                     if let Some(session) = state.get_peer_session(&peer_id) {
                         debug!(
-                                    "Randomly selected peer {:?} already connected with session id {:?}, skipping connection",
-                                    peer_id, session
-                                );
+                            "Randomly selected peer {:?} already connected with session id {:?}, skipping connection",
+                            peer_id, session
+                        );
                         continue;
                     }
 
@@ -1765,6 +1834,11 @@ where
                 }
             }
             NetworkActorCommand::SettleTlcSet(payment_hash, tlc_info) => {
+                // NOTE: there are three scenarios to settle a tlc set:
+                // 1. non-mpp tlc set: tlc_info is Some(_), including hold tlc which may don't have preimage yet
+                // 2. mpp tlc set with invoice: tlc_info is None
+                // 3. atomic mpp tlc set without invoice: tlc_info is None
+
                 let tlc_ids = if let Some((channel_id, tlc_id)) = tlc_info {
                     vec![(channel_id, tlc_id)]
                 } else {
@@ -1782,61 +1856,180 @@ where
                         state.get_received_tlc(tlc_id).cloned()
                     })
                     .collect();
-
-                let not_mpp = tlc_info.is_some();
-                let mut tlc_fail = None;
-
-                // check if all tlcs have the same total amount
-                if tlcs.len() > 1
-                    && !tlcs
-                        .windows(2)
-                        .all(|w| w[0].total_amount == w[1].total_amount)
-                {
-                    error!("TLCs have inconsistent total_amount: {:?}", tlcs);
-                    tlc_fail = Some(TlcErr::new(TlcErrorCode::IncorrectOrUnknownPaymentDetails));
+                if tlcs.is_empty() {
+                    return Ok(());
                 }
-                let Some(invoice) = self.store.get_invoice(&payment_hash) else {
-                    error!(
-                        "Try to settle mpp tlc set, but invoice not found for payment hash {:?}",
-                        payment_hash
-                    );
+
+                let invoice = self.store.get_invoice(&payment_hash);
+                let preimage = self.store.get_preimage(&payment_hash);
+                if invoice.is_some() && preimage.is_none() {
+                    // hold tlc may not have preimage yet
                     return Ok(());
-                };
+                }
 
-                let fulfilled = is_invoice_fulfilled(&invoice, &tlcs);
-                if not_mpp {
-                    if self.store.get_invoice_status(&payment_hash) != Some(CkbInvoiceStatus::Open)
-                        || !fulfilled
+                // we generally set all validation error as IncorrectOrUnknownPaymentDetails, this failure
+                // is expected to be the scenarios malicious sender have sent a inconsistent data with MPP,
+                // and we don't want to keep them in the database.
+                let mut tlc_preimage_map = HashMap::new();
+                let tlc_fail = 'validation: {
+                    macro_rules! validation_fail {
+                        ($msg:expr) => {{
+                            error!($msg, payment_hash);
+                            break 'validation Some(TlcErr::new(
+                                TlcErrorCode::IncorrectOrUnknownPaymentDetails,
+                            ));
+                        }};
+                    }
+
+                    // check if all tlcs have the same total amount
+                    if tlcs.len() > 1
+                        && !tlcs.windows(2).all(|w| {
+                            w[0].total_amount == w[1].total_amount
+                                && w[0].hash_algorithm == w[1].hash_algorithm
+                        })
                     {
-                        tlc_fail =
-                            Some(TlcErr::new(TlcErrorCode::IncorrectOrUnknownPaymentDetails));
+                        validation_fail!("TLCs have inconsistent information: {:?}");
                     }
-                } else if !fulfilled {
-                    return Ok(());
-                }
 
-                // if we have enough tlcs to fulfill the invoice, update invoice status to Received
-                // for hold invoice we may don't have preimages yet, so just update status here
-                self.store
-                    .update_invoice_status(&payment_hash, CkbInvoiceStatus::Received)
-                    .expect("update invoice status failed");
+                    if let Some(ref invoice) = invoice {
+                        let fulfilled = is_invoice_fulfilled(invoice, &tlcs);
+                        // for non-mpp tlc set, we expect the invoice is fulfilled
+                        if tlc_info.is_some()
+                            && (self.store.get_invoice_status(&payment_hash)
+                                != Some(CkbInvoiceStatus::Open)
+                                || !fulfilled)
+                        {
+                            error!(
+                                "got in old status: {:?}",
+                                self.store.get_invoice_status(&payment_hash)
+                            );
+                            validation_fail!(
+                                "Try to settle non-mpp tlc set but invoice is not fulfilled: {:?}"
+                            );
+                        }
+                    }
 
-                let Some(preimage) = self.store.get_preimage(&payment_hash) else {
-                    return Ok(());
+                    // check if tlc set are fulfilled
+                    let hash_algorithm = tlcs[0].hash_algorithm;
+                    let mpp_mode = match invoice {
+                        Some(ref invoice) => {
+                            if !is_invoice_fulfilled(invoice, &tlcs) {
+                                return Ok(());
+                            }
+                            let mpp_mode = invoice.mpp_mode();
+                            if invoice.hash_algorithm().cloned().unwrap_or_default()
+                                != hash_algorithm
+                            {
+                                validation_fail!("TLCs hash_algorithm does not match invoice for mpp payment_hash: {:?}");
+                            }
+                            mpp_mode
+                        }
+                        None => {
+                            if !is_atomic_mpp_fulfilled(&tlcs) {
+                                return Ok(());
+                            }
+                            Some(MppMode::AtomicMpp)
+                        }
+                    };
+
+                    // Generate preimages based on MPP mode
+                    match mpp_mode {
+                        Some(MppMode::BasicMpp) | None => {
+                            let Some(preimage) = preimage else {
+                                validation_fail!("can not get preimage for payment: {:?}");
+                            };
+
+                            for tlc in tlcs.iter() {
+                                tlc_preimage_map.insert((tlc.channel_id, tlc.id()), preimage);
+                            }
+                        }
+                        Some(MppMode::AtomicMpp) => {
+                            let mut tlcs_mpp_data =
+                                self.store.get_atomic_mpp_payment_data(&payment_hash);
+
+                            if tlcs_mpp_data.len() != tlcs.len() {
+                                validation_fail!(
+                                    "atomic mpp don't have enough mpp data for payment_hash: {:?}"
+                                );
+                            }
+
+                            tlcs_mpp_data.sort_by(|(_, a), (_, b)| a.index().cmp(&b.index()));
+                            let index: Vec<u16> =
+                                tlcs_mpp_data.iter().map(|(_, data)| data.index()).collect();
+
+                            let total_count = tlcs_mpp_data[0].1.total_amp_count;
+                            if tlcs_mpp_data
+                                .iter()
+                                .any(|(_, data)| data.total_amp_count != total_count)
+                            {
+                                validation_fail!("atomic mpp total count are not the same for payment_hash: {:?}");
+                            }
+
+                            let expected_index: Vec<u16> = (0..total_count).collect();
+                            if index != expected_index {
+                                validation_fail!(
+                                    "atomic mpp index are not expected for payment_hash: {:?}"
+                                );
+                            }
+
+                            let child_descs: Vec<AmpChildDesc> = tlcs_mpp_data
+                                .iter()
+                                .map(|(_, data)| data.child_desc.clone())
+                                .collect();
+                            let children =
+                                AmpChild::reconstruct_amp_children(&child_descs, hash_algorithm);
+                            debug_assert_eq!(child_descs.len(), children.len());
+
+                            for (((channel_id, tlc_id), _), child) in
+                                tlcs_mpp_data.iter().zip(children.iter())
+                            {
+                                tlc_preimage_map.insert((*channel_id, *tlc_id), child.preimage);
+                            }
+
+                            // verify the preimages
+                            for tlc in tlcs.iter() {
+                                let payment_hash = tlc.payment_hash;
+                                let preimage = tlc_preimage_map
+                                    .get(&(tlc.channel_id, tlc.id()))
+                                    .expect("must got preimage");
+                                let hash: Hash256 = hash_algorithm.hash(preimage.as_ref()).into();
+                                if hash != payment_hash {
+                                    validation_fail!(
+                                        "verify AMP preimage for payment hash {:?} is not valid"
+                                    );
+                                }
+                            }
+                        }
+                    }
+                    None
                 };
 
+                if invoice.is_some() {
+                    // if we have enough tlcs to fulfill the invoice, update invoice status to Received
+                    // for hold invoice we may don't have preimages yet, so just update status here
+                    self.store
+                        .update_invoice_status(&payment_hash, CkbInvoiceStatus::Received)
+                        .expect("update invoice status failed");
+                }
+
                 // remove tlcs
                 for tlc in tlcs {
                     let (send, _recv) = oneshot::channel();
                     let rpc_reply = RpcReplyPort::from(send);
+
                     let remove_reason = match tlc_fail.clone() {
                         Some(tlc_fail) => RemoveTlcReason::RemoveTlcFail(TlcErrPacket::new(
                             tlc_fail,
                             &tlc.shared_secret,
                         )),
-                        None => RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
-                            payment_preimage: preimage,
-                        }),
+                        None => {
+                            let preimage = *tlc_preimage_map
+                                .get(&(tlc.channel_id, tlc.id()))
+                                .expect("must got preimage");
+                            RemoveTlcReason::RemoveTlcFulfill(RemoveTlcFulfill {
+                                payment_preimage: preimage,
+                            })
+                        }
                     };
 
                     match state
@@ -2606,23 +2799,23 @@ where
                         TlcErr::new(TlcErrorCode::InvalidOnionError)
                     });
                 debug!("on_remove_tlc: {:?}", error_detail.error_code);
-                let need_to_retry = self.network_graph.write().await.record_attempt_fail(
+                let need_retry = self.network_graph.write().await.record_attempt_fail(
                     &attempt,
                     error_detail.clone(),
                     false,
                 );
                 debug!(
-                    "payment_hash: {:?} set attempt failed with: {:?} need_to_retry: {:?}",
+                    "payment_hash: {:?} set attempt failed with: {:?} need_retry: {:?}",
                     payment_hash,
                     error_detail.error_code.as_ref(),
-                    need_to_retry
+                    need_retry
                 );
 
                 self.set_attempt_fail_with_error(
                     &mut session,
                     &mut attempt,
                     error_detail.error_code.as_ref(),
-                    need_to_retry,
+                    need_retry,
                 );
 
                 if attempt.is_retrying() {
@@ -2704,12 +2897,19 @@ where
 
             session.request.channel_stats = GraphChannelStat::new(Some(graph.channel_stats()));
 
-            let hops = graph
+            let mut hops = graph
                 .build_route(amount, None, max_fee, &session.request)
-                .map_err(|e| {
-                    Error::BuildPaymentRouteError(format!("Failed to build route, {}", e))
-                })?;
-
+                .map_err(|e| Error::BuildPaymentRouteError(e.to_string()))?;
+
+            // reuse the previous custom_records in hops
+            if session.is_atomic_mpp() {
+                hops.last_mut().expect("hops not empty").custom_records = attempt
+                    .route_hops
+                    .last()
+                    .expect("hops not empty")
+                    .custom_records
+                    .clone();
+            }
             attempt.update_route(hops);
         }
 
@@ -2722,6 +2922,7 @@ where
         session: &mut PaymentSession,
     ) -> Result<Vec<Attempt>, Error> {
         let graph = self.network_graph.read().await;
+        let amp_mpp = session.request.allow_atomic_mpp;
         let source = graph.get_source_pubkey();
         let active_parts = session.attempts().filter(|a| a.is_active()).count();
         let mut remain_amount = session.remain_amount();
@@ -2807,6 +3008,15 @@ where
             return Err(Error::SendPaymentError(error));
         }
 
+        // generate custom records for amp_mpp
+        if amp_mpp {
+            self.set_amp_custom_records(
+                &mut result,
+                session.payment_hash(),
+                session.remain_amount(),
+            );
+        }
+
         for attempt in &result {
             session.append_attempt(attempt.clone());
         }
@@ -2814,6 +3024,41 @@ where
         return Ok(result);
     }
 
+    fn set_amp_custom_records(
+        &self,
+        attempts: &mut [Attempt],
+        payment_hash: Hash256,
+        total_amount: u128,
+    ) {
+        debug_assert!(!attempts.is_empty());
+
+        let root = AmpSecret::random();
+        let secrets = AmpSecret::gen_random_sequence(root, attempts.len() as u16);
+        let hash_algorithm = attempts[0].route_hops.first().unwrap().hash_algorithm;
+
+        let total_count = attempts.len() as u16;
+        let child_descs: Vec<_> = secrets
+            .iter()
+            .enumerate()
+            .map(|(i, &share)| AmpChildDesc::new(i as u16, share))
+            .collect();
+
+        let children = AmpChild::reconstruct_amp_children(&child_descs, hash_algorithm);
+        for (index, (attempt, child)) in attempts.iter_mut().zip(&children).enumerate() {
+            let last_hop = attempt.route_hops.last_mut().expect("last hop");
+            let amp_data = AmpPaymentData::new(
+                payment_hash,
+                total_count,
+                child_descs[index].clone(),
+                total_amount,
+            );
+            let mut custom_records = last_hop.custom_records.clone().unwrap_or_default();
+            amp_data.write(&mut custom_records);
+            last_hop.custom_records = Some(custom_records);
+            attempt.hash = child.hash;
+        }
+    }
+
     async fn send_payment_onion_packet(
         &self,
         state: &mut NetworkActorState<S>,
@@ -2834,8 +3079,8 @@ where
             Ok(packet) => packet,
             Err(e) => {
                 let err = format!(
-                    "Failed to create onion packet: {:?}, error: {:?}",
-                    attempt.hash, e
+                    "Failed to create onion packet for attempt_hash: {:?} with payment_hash: {:?}, error: {:?}",
+                    attempt.hash, attempt.payment_hash, e
                 );
                 self.set_attempt_fail_with_error(session, attempt, &err, false);
                 return Err(Error::FirstHopError(err, false));
@@ -2848,7 +3093,7 @@ where
                 SendOnionPacketCommand {
                     peeled_onion_packet,
                     previous_tlc: None,
-                    payment_hash: attempt.payment_hash,
+                    payment_hash: attempt.hash,
                     attempt_id: Some(attempt.id),
                 },
             )
@@ -2857,7 +3102,7 @@ where
             Err(error_detail) => {
                 self.update_graph_with_tlc_fail(&state.network, &error_detail)
                     .await;
-                let need_to_retry = self.network_graph.write().await.record_attempt_fail(
+                let need_retry = self.network_graph.write().await.record_attempt_fail(
                     attempt,
                     error_detail.clone(),
                     true,
@@ -2866,8 +3111,8 @@ where
                     "Failed to send onion packet with error {}",
                     error_detail.error_code_as_str()
                 );
-                self.set_attempt_fail_with_error(session, attempt, &err, need_to_retry);
-                return Err(Error::FirstHopError(err, need_to_retry));
+                self.set_attempt_fail_with_error(session, attempt, &err, need_retry);
+                return Err(Error::FirstHopError(err, need_retry));
             }
             Ok(_) => {
                 self.store.insert_attempt(attempt.clone());
@@ -2930,7 +3175,7 @@ where
             }
             Some((error, tlc_err)) => {
                 self.update_graph_with_tlc_fail(&myself, &tlc_err).await;
-                let need_to_retry = self.network_graph.write().await.record_attempt_fail(
+                let need_retry = self.network_graph.write().await.record_attempt_fail(
                     &attempt,
                     tlc_err.clone(),
                     true,
@@ -2939,7 +3184,7 @@ where
                     &mut session,
                     &mut attempt,
                     &error.to_string(),
-                    need_to_retry,
+                    need_retry,
                 );
                 // retry the current attempt if it is retryable
                 if attempt.is_retrying() {
@@ -3066,8 +3311,8 @@ where
                     .resend_payment_attempt(myself, state, session, &mut attempt)
                     .await
                 {
-                    Err(err) if session.allow_mpp() => {
-                        // usually `resend_payment_route` will only try build a route with same amount,
+                    Err(err) if session.is_basic_mpp() => {
+                        // usually `resend_payment_attempt` will only try build a route with same amount,
                         // because most of the time, resend payment caused by the first hop
                         // error with WaitingTlcAck, if resend failed we should try more attempts in MPP,
                         // so we may create more attempts with different split amounts
@@ -3081,6 +3326,11 @@ where
                             &err.to_string(),
                             false,
                         );
+                        // for atomic mpp, we are sure now one of attempt already failed and we will not retry
+                        // so it's safe we update payment_session status to failed
+                        if session.is_atomic_mpp() {
+                            self.set_payment_fail_with_error(session, "Part of AMP failed");
+                        }
                         return Err(err);
                     }
                     _ => {}
diff --git a/crates/fiber-lib/src/fiber/payment.rs b/crates/fiber-lib/src/fiber/payment.rs
index ca08d66c4..6d2c5aac6 100644
--- a/crates/fiber-lib/src/fiber/payment.rs
+++ b/crates/fiber-lib/src/fiber/payment.rs
@@ -6,11 +6,18 @@ use crate::fiber::network::DEFAULT_PAYMENT_MPP_ATTEMPT_TRY_LIMIT;
 use crate::fiber::serde_utils::EntityHex;
 use crate::fiber::serde_utils::U128Hex;
 use crate::fiber::types::PaymentHopData;
+use crate::fiber::PaymentCustomRecords;
 use crate::now_timestamp_as_millis_u64;
 use ckb_types::packed::OutPoint;
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum MppMode {
+    BasicMpp,
+    AtomicMpp,
+}
+
 /// The status of a payment, will update as the payment progresses.
 /// The transfer path for payment status is `Created -> Inflight -> Success | Failed`.
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
@@ -165,6 +172,14 @@ impl PaymentSession {
         self.request.allow_mpp()
     }
 
+    pub fn is_basic_mpp(&self) -> bool {
+        self.request.is_basic_mpp()
+    }
+
+    pub fn is_atomic_mpp(&self) -> bool {
+        self.request.is_atomic_mpp()
+    }
+
     pub fn payment_hash(&self) -> Hash256 {
         self.request.payment_hash
     }
@@ -278,6 +293,7 @@ impl PaymentSession {
             last_updated_at: now,
             last_error: None,
             status: AttemptStatus::Created,
+            custom_records: None,
         }
     }
 
@@ -454,6 +470,7 @@ pub struct Attempt {
     pub created_at: u64,
     pub last_updated_at: u64,
     pub last_error: Option<String>,
+    pub custom_records: Option<PaymentCustomRecords>,
 }
 
 impl Attempt {
diff --git a/crates/fiber-lib/src/fiber/tests/amp.rs b/crates/fiber-lib/src/fiber/tests/amp.rs
new file mode 100644
index 000000000..6617d5989
--- /dev/null
+++ b/crates/fiber-lib/src/fiber/tests/amp.rs
@@ -0,0 +1,487 @@
+use crate::{
+    create_n_nodes_network_with_params,
+    fiber::{
+        network::SendPaymentCommand,
+        payment::{AttemptStatus, MppMode},
+    },
+    gen_rand_sha256_hash, gen_rpc_config,
+    invoice::{Currency, InvoiceBuilder},
+    rpc::invoice::NewInvoiceParams,
+    test_utils::{create_n_nodes_network, init_tracing, MIN_RESERVED_CKB},
+    ChannelParameters, HUGE_CKB_AMOUNT,
+};
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_basic_amp() {
+    init_tracing();
+
+    let (nodes, channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+    )
+    .await;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let res = node_0
+        .send_atomic_mpp_payment(&node_1, 20000000000, Some(2))
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+
+    let payment_session = node_0.get_payment_session(payment_hash).unwrap();
+    dbg!(&payment_session.status, &payment_session.attempts_count());
+
+    let node_0_balance = node_0.get_local_balance_from_channel(channels[0]);
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[0]);
+    dbg!(node_0_balance, node_1_balance);
+    assert_eq!(node_0_balance, 0);
+    assert_eq!(node_1_balance, 10000000000);
+
+    let node_0_balance = node_0.get_local_balance_from_channel(channels[1]);
+    let node_1_balance = node_1.get_local_balance_from_channel(channels[1]);
+    dbg!(node_0_balance, node_1_balance);
+    assert_eq!(node_0_balance, 0);
+    assert_eq!(node_1_balance, 10000000000);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_single_amp_path() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+    )
+    .await;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let res = node_0
+        .send_atomic_mpp_payment(&node_1, 10000000000, Some(2))
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+    let attempts = node_0
+        .get_payment_session(payment_hash)
+        .unwrap()
+        .attempts_count();
+    assert_eq!(attempts, 1);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_amp_without_invoice() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        2,
+    )
+    .await;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+
+    let target_pubkey = node_1.get_public_key();
+    let amount = 20000000000;
+    let builder = InvoiceBuilder::new(Currency::Fibd)
+        .amount(Some(amount))
+        .payee_pub_key(target_pubkey.into())
+        .allow_atomic_mpp(true)
+        .payment_hash(gen_rand_sha256_hash());
+
+    let ckb_invoice = builder.build().expect("build invoice success");
+    // we don't insert the invoice into the store
+    //node_1.insert_invoice(ckb_invoice.clone(), None);
+    let command = SendPaymentCommand {
+        max_parts: Some(2),
+        invoice: Some(ckb_invoice.to_string()),
+        atomic_mpp: Some(true),
+        ..Default::default()
+    };
+    let res = node_0.send_payment(command).await;
+    let payment_hash = res.unwrap().payment_hash;
+
+    node_0.wait_until_success(payment_hash).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_3_nodes_in_middle() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((2, 3), (HUGE_CKB_AMOUNT, MIN_RESERVED_CKB)),
+        ],
+        4,
+    )
+    .await;
+    let [node_0, _node_1, _node_2, node_3] = nodes.try_into().expect("4 nodes");
+    let res = node_0
+        .send_atomic_mpp_payment(&node_3, 30000000000, Some(3))
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_3_nodes_in_last_hop() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT)),
+            ((1, 2), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT)),
+            ((2, 3), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((2, 3), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((2, 3), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+        ],
+        4,
+    )
+    .await;
+    let [node_0, _node_1, _node_2, node_3] = nodes.try_into().expect("4 nodes");
+    let res = node_0
+        .send_atomic_mpp_payment(&node_3, 30000000000, Some(3))
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_mpp_3_nodes_pay_self() {
+    init_tracing();
+
+    async fn test_pay_self(mpp_mode: MppMode) {
+        let (nodes, _channels) = create_n_nodes_network(
+            &[
+                ((0, 1), (MIN_RESERVED_CKB + 66000, HUGE_CKB_AMOUNT)),
+                ((1, 2), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT)),
+                ((2, 3), (MIN_RESERVED_CKB + 11000, MIN_RESERVED_CKB)),
+                ((2, 3), (MIN_RESERVED_CKB + 11000, MIN_RESERVED_CKB)),
+                ((2, 3), (MIN_RESERVED_CKB + 11000, MIN_RESERVED_CKB)),
+                // path_find will first try this direction, since it's with larger capacity
+                // but the middle hops for this direction don't have enough capacity
+                // so path finding should try another direction and succeed
+                ((3, 0), (MIN_RESERVED_CKB + 76000, HUGE_CKB_AMOUNT)),
+            ],
+            4,
+        )
+        .await;
+        let [node_0, _node_1, _node_2, _node_3] = nodes.try_into().expect("4 nodes");
+
+        let res = node_0
+            .send_mpp_payment_with_command(
+                &node_0,
+                30000,
+                SendPaymentCommand {
+                    max_parts: Some(3),
+                    allow_self_payment: true,
+                    ..Default::default()
+                },
+                mpp_mode,
+            )
+            .await;
+
+        eprintln!("res: {:?}", res);
+        assert!(res.is_ok());
+        let payment_hash = res.unwrap().payment_hash;
+        node_0.wait_until_success(payment_hash).await;
+    }
+
+    test_pay_self(MppMode::BasicMpp).await;
+    test_pay_self(MppMode::AtomicMpp).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_amp_can_handle_retry_in_middle() {
+    init_tracing();
+
+    // we have 4 channels in the middle, but we disable a channel quite,
+    // AMP can handle retry router currently
+    let (nodes, channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10100000000, MIN_RESERVED_CKB)),
+            ((2, 3), (HUGE_CKB_AMOUNT, MIN_RESERVED_CKB)),
+        ],
+        4,
+    )
+    .await;
+    let [node_0, node_1, _node_2, node_3] = nodes.try_into().expect("4 nodes");
+
+    node_1.disable_channel_stealthy(channels[3]).await;
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    let res = node_0
+        .send_atomic_mpp_payment(&node_3, 30000000000, Some(3))
+        .await;
+
+    eprintln!("res: {:?}", res);
+    assert!(res.is_ok());
+    let payment_hash = res.unwrap().payment_hash;
+    node_0.wait_until_success(payment_hash).await;
+
+    let payment_session = node_0.get_payment_session(payment_hash).unwrap();
+    let mut attempts = payment_session.attempts();
+    assert!(attempts.any(|x| x.tried_times >= 2));
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_send_mpp_split_in_retry() {
+    init_tracing();
+
+    async fn run_test(mpp_mode: MppMode, expect_status: AttemptStatus) {
+        let (nodes, channels) = create_n_nodes_network(
+            &[
+                ((0, 1), (MIN_RESERVED_CKB + 66000, HUGE_CKB_AMOUNT)),
+                // these two channels will selected when retry
+                ((1, 2), (MIN_RESERVED_CKB + 6000, MIN_RESERVED_CKB)),
+                ((1, 2), (MIN_RESERVED_CKB + 6000, MIN_RESERVED_CKB)),
+                // these two channels will used in first try
+                ((1, 2), (MIN_RESERVED_CKB + 11000, MIN_RESERVED_CKB)),
+                ((1, 2), (MIN_RESERVED_CKB + 11000, MIN_RESERVED_CKB)),
+                ((2, 3), (MIN_RESERVED_CKB + 66000, HUGE_CKB_AMOUNT)),
+            ],
+            4,
+        )
+        .await;
+        let [node_0, node_1, _node_2, node_3] = nodes.try_into().expect("4 nodes");
+
+        node_1.disable_channel_stealthy(channels[4]).await;
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+        let res = node_0
+            .send_mpp_payment_with_command(
+                &node_3,
+                20000,
+                SendPaymentCommand {
+                    max_parts: Some(15),
+                    allow_self_payment: true,
+                    ..Default::default()
+                },
+                mpp_mode,
+            )
+            .await;
+
+        eprintln!("res: {:?}", res);
+        assert!(res.is_ok());
+        let payment_hash = res.unwrap().payment_hash;
+        if expect_status == AttemptStatus::Success {
+            node_0.wait_until_success(payment_hash).await;
+            let payment_session = node_0.get_payment_session(payment_hash).unwrap();
+            let total_amount: u128 = payment_session
+                .attempts()
+                .filter(|a| a.status == AttemptStatus::Success)
+                .map(|a| a.route.receiver_amount())
+                .sum();
+            assert_eq!(total_amount, 20000);
+            assert!(
+                payment_session
+                    .attempts()
+                    .filter(|a| a.status == AttemptStatus::Success)
+                    .count()
+                    <= 15
+            );
+        } else {
+            node_0.wait_until_failed(payment_hash).await;
+            let payment_session = node_0.get_payment_session(payment_hash).unwrap();
+            // assert AMP don't try to split more channels when retrying
+            assert_eq!(payment_session.attempts_count(), 2);
+        }
+    }
+
+    run_test(MppMode::BasicMpp, AttemptStatus::Success).await;
+    // Atomic mpp can not handle this scenario now
+    run_test(MppMode::AtomicMpp, AttemptStatus::Failed).await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_mpp_multiple_payment_with_same_invoice() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network_with_params(
+        &[
+            (
+                (0, 1),
+                ChannelParameters {
+                    public: true,
+                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
+                    node_b_funding_amount: MIN_RESERVED_CKB,
+                    ..Default::default()
+                },
+            ),
+            (
+                (0, 1),
+                ChannelParameters {
+                    public: true,
+                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
+                    node_b_funding_amount: MIN_RESERVED_CKB,
+                    ..Default::default()
+                },
+            ),
+        ],
+        2,
+        Some(gen_rpc_config()),
+    )
+    .await;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+
+    let invoice = node_1
+        .gen_invoice(NewInvoiceParams {
+            amount: 100000,
+            allow_atomic_mpp: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    let invoice_str = invoice.invoice_address;
+
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            invoice: Some(invoice_str.clone()),
+            atomic_mpp: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    node_0.wait_until_success(res.unwrap().payment_hash).await;
+
+    // send the same invoice multiple times
+
+    for _i in 0..3 {
+        let res = node_0
+            .send_payment(SendPaymentCommand {
+                invoice: Some(invoice_str.clone()),
+                atomic_mpp: Some(true),
+                ..Default::default()
+            })
+            .await;
+
+        node_0.wait_until_success(res.unwrap().payment_hash).await;
+    }
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_amp_without_invoice_multiple_times() {
+    init_tracing();
+
+    let (nodes, _channels) =
+        create_n_nodes_network(&[((0, 1), (HUGE_CKB_AMOUNT, HUGE_CKB_AMOUNT))], 2).await;
+
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_1.get_public_key()),
+            amount: Some(100000),
+            atomic_mpp: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    node_0.wait_until_success(res.unwrap().payment_hash).await;
+
+    // send the same invoice multiple times
+
+    for _i in 0..3 {
+        let res = node_0
+            .send_payment(SendPaymentCommand {
+                target_pubkey: Some(node_1.get_public_key()),
+                amount: Some(100000),
+                atomic_mpp: Some(true),
+                ..Default::default()
+            })
+            .await;
+
+        node_0.wait_until_success(res.unwrap().payment_hash).await;
+    }
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn test_amp_flags_checking() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network_with_params(
+        &[
+            (
+                (0, 1),
+                ChannelParameters {
+                    public: true,
+                    node_a_funding_amount: HUGE_CKB_AMOUNT,
+                    node_b_funding_amount: HUGE_CKB_AMOUNT,
+                    ..Default::default()
+                },
+            ),
+            (
+                (0, 1),
+                ChannelParameters {
+                    public: true,
+                    node_a_funding_amount: HUGE_CKB_AMOUNT,
+                    node_b_funding_amount: HUGE_CKB_AMOUNT,
+                    ..Default::default()
+                },
+            ),
+        ],
+        2,
+        Some(gen_rpc_config()),
+    )
+    .await;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+
+    let invoice = node_1
+        .gen_invoice(NewInvoiceParams {
+            amount: 100000,
+            allow_atomic_mpp: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            invoice: Some(invoice.invoice_address),
+            atomic_mpp: Some(false),
+            ..Default::default()
+        })
+        .await;
+
+    let err = res.expect_err("expect failed");
+    assert!(err.contains("It is a AMP invoice, need to set amp flag in SendPayment"));
+
+    let invoice = node_1
+        .gen_invoice(NewInvoiceParams {
+            amount: 100000,
+            allow_atomic_mpp: Some(false),
+            ..Default::default()
+        })
+        .await;
+    let res = node_0
+        .send_payment(SendPaymentCommand {
+            invoice: Some(invoice.invoice_address),
+            atomic_mpp: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    let err = res.expect_err("expect failed");
+    assert!(err.contains("AMP flag can not set for a non-AMP invoice"));
+}
diff --git a/crates/fiber-lib/src/fiber/tests/channel.rs b/crates/fiber-lib/src/fiber/tests/channel.rs
index 1562739ca..2f0c76f1e 100644
--- a/crates/fiber-lib/src/fiber/tests/channel.rs
+++ b/crates/fiber-lib/src/fiber/tests/channel.rs
@@ -3064,6 +3064,7 @@ async fn do_test_add_tlc_value_limit() {
         .expect("node_b alive");
         // sleep for a while to make sure the AddTlc processed by both party
         tokio::time::sleep(tokio::time::Duration::from_millis(300)).await;
+        eprintln!("add_tlc_result: {:?}", add_tlc_result);
         assert!(add_tlc_result.is_ok());
     }
 }
@@ -4977,7 +4978,10 @@ async fn test_send_payment_with_channel_balance_error() {
     let res = source_node.get_payment_result(payment_hash).await;
 
     assert_eq!(res.status, PaymentStatus::Failed);
-    assert!(res.failed_error.unwrap().contains("Failed to build route"));
+    assert!(res
+        .failed_error
+        .unwrap()
+        .contains("PathFind error: no path found"));
 
     // because there is only one path for the payment, the payment will fail in the second try
     // this assertion make sure we didn't do meaningless retry
diff --git a/crates/fiber-lib/src/fiber/tests/graph.rs b/crates/fiber-lib/src/fiber/tests/graph.rs
index 5c0b03ce3..cd73de89e 100644
--- a/crates/fiber-lib/src/fiber/tests/graph.rs
+++ b/crates/fiber-lib/src/fiber/tests/graph.rs
@@ -623,7 +623,8 @@ fn test_graph_build_router_is_ok_with_fee_rate() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -673,7 +674,8 @@ fn test_graph_build_router_fee_rate_optimize() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
 
@@ -715,7 +717,8 @@ fn test_graph_build_router_no_fee_with_direct_pay() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -867,7 +870,8 @@ fn test_graph_build_route_three_nodes_amount() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -926,7 +930,8 @@ fn do_test_graph_build_route_expiry(n_nodes: usize) {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1016,7 +1021,8 @@ fn test_graph_build_route_below_min_tlc_value() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1053,7 +1059,8 @@ fn test_graph_build_route_select_edge_with_latest_timestamp() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1098,7 +1105,8 @@ fn test_graph_build_route_select_edge_with_large_capacity() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1162,7 +1170,8 @@ fn test_graph_mark_failed_channel() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1192,7 +1201,8 @@ fn test_graph_mark_failed_channel() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1233,7 +1243,8 @@ fn test_graph_session_router() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1287,7 +1298,8 @@ fn test_graph_mark_failed_node() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1315,7 +1327,8 @@ fn test_graph_mark_failed_node() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1345,7 +1358,8 @@ fn test_graph_mark_failed_node() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
@@ -1372,7 +1386,8 @@ fn test_graph_mark_failed_node() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let route = network
diff --git a/crates/fiber-lib/src/fiber/tests/mod.rs b/crates/fiber-lib/src/fiber/tests/mod.rs
index f1c29b7d2..ef88203fb 100644
--- a/crates/fiber-lib/src/fiber/tests/mod.rs
+++ b/crates/fiber-lib/src/fiber/tests/mod.rs
@@ -1,3 +1,5 @@
+#[cfg(not(target_arch = "wasm32"))]
+mod amp;
 mod channel;
 mod features;
 mod gossip;
diff --git a/crates/fiber-lib/src/fiber/tests/mpp.rs b/crates/fiber-lib/src/fiber/tests/mpp.rs
index 0eb24a43e..c333b25db 100644
--- a/crates/fiber-lib/src/fiber/tests/mpp.rs
+++ b/crates/fiber-lib/src/fiber/tests/mpp.rs
@@ -5,6 +5,7 @@ use tracing::debug;
 use crate::{
     create_n_nodes_network_with_params,
     fiber::{
+        builtin_records::BasicMppPaymentData,
         channel::{
             AddTlcCommand, ChannelActorStateStore, ChannelCommand, ChannelCommandWithId, TLCId,
         },
@@ -12,10 +13,8 @@ use crate::{
         features::FeatureVector,
         hash_algorithm::HashAlgorithm,
         network::{DebugEvent, SendPaymentCommand, USER_CUSTOM_RECORDS_MAX_INDEX},
-        payment::{AttemptStatus, PaymentStatus},
-        types::{
-            BasicMppPaymentData, Hash256, PaymentHopData, PeeledPaymentOnionPacket, RemoveTlcReason,
-        },
+        payment::{AttemptStatus, MppMode, PaymentStatus},
+        types::{Hash256, PaymentHopData, PeeledPaymentOnionPacket, RemoveTlcReason},
         NetworkActorCommand, NetworkActorMessage, PaymentCustomRecords,
     },
     gen_rand_secp256k1_public_key, gen_rand_sha256_hash, gen_rpc_config,
@@ -97,7 +96,7 @@ async fn test_send_mpp_to_hold_invoice() {
         .amount(Some(20000000000))
         .payment_hash(payment_hash)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -151,8 +150,8 @@ async fn test_send_mpp_will_not_enabled_if_not_set_allow_mpp() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -201,7 +200,7 @@ async fn test_send_mpp_without_payment_secret_will_fail() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .build();
 
     let error = ckb_invoice.unwrap_err().to_string();
@@ -517,7 +516,7 @@ async fn test_send_mpp_fee_rate() {
         .amount(Some(1_500_000_000))
         .payment_preimage(preimage)
         .payee_pub_key(node_2.pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -549,8 +548,8 @@ async fn test_mpp_tlc_set() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -559,7 +558,7 @@ async fn test_mpp_tlc_set() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -688,8 +687,8 @@ async fn test_mpp_tlc_set_with_insufficient_total_amount() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -698,7 +697,7 @@ async fn test_mpp_tlc_set_with_insufficient_total_amount() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -826,8 +825,8 @@ async fn test_mpp_tlc_set_with_only_1_tlc() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -836,7 +835,7 @@ async fn test_mpp_tlc_set_with_only_1_tlc() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -930,8 +929,8 @@ async fn test_mpp_tlc_set_with_only_1_tlc_without_payment_data() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -940,7 +939,7 @@ async fn test_mpp_tlc_set_with_only_1_tlc_without_payment_data() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1031,8 +1030,8 @@ async fn test_mpp_tlc_set_total_amount_mismatch() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -1041,7 +1040,7 @@ async fn test_mpp_tlc_set_total_amount_mismatch() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1181,8 +1180,8 @@ async fn test_mpp_tlc_set_total_amount_should_be_consistent() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -1191,7 +1190,7 @@ async fn test_mpp_tlc_set_total_amount_should_be_consistent() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1358,8 +1357,8 @@ async fn test_mpp_tlc_set_payment_secret_mismatch() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -1368,7 +1367,7 @@ async fn test_mpp_tlc_set_payment_secret_mismatch() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1508,8 +1507,8 @@ async fn test_mpp_tlc_set_timeout_1_of_2() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -1521,7 +1520,7 @@ async fn test_mpp_tlc_set_timeout_1_of_2() {
         .amount(Some(30000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1724,8 +1723,8 @@ async fn test_mpp_tlc_set_timeout() {
         2,
     )
     .await;
-    let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-    let source_node = &mut node_0;
+    let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+    let source_node = &node_0;
     let target_pubkey = node_1.pubkey;
 
     let preimage = gen_rand_sha256_hash();
@@ -1734,7 +1733,7 @@ async fn test_mpp_tlc_set_timeout() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -1911,7 +1910,7 @@ async fn test_mpp_tlc_set_without_payment_data() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -2057,7 +2056,7 @@ async fn test_send_mpp_dry_run_will_be_ok_with_single_path() {
         .await;
         let [node_0, _node_1, node_2] = nodes.try_into().expect("ok nodes");
         let res = node_0
-            .send_mpp_payment_with_dry_run_option(&node_2, amount, None, true)
+            .send_mpp_payment_with_dry_run_option(&node_2, amount, None, true, MppMode::BasicMpp)
             .await;
 
         if let Some(count) = expect_routers_count {
@@ -2099,7 +2098,7 @@ async fn test_send_mpp_direct_channels_dry_run() {
         let [node_0, node_1, _node_2] = nodes.try_into().expect("ok nodes");
 
         let res = node_0
-            .send_mpp_payment_with_dry_run_option(&node_1, amount, None, true)
+            .send_mpp_payment_with_dry_run_option(&node_1, amount, None, true, MppMode::BasicMpp)
             .await;
 
         if let Some(count) = expect_routers_count {
@@ -2144,7 +2143,7 @@ async fn test_send_mpp_dry_run_single_path_mixed_with_multiple_paths() {
         .await;
         let [node_0, _node_1, node_2] = nodes.try_into().expect("ok nodes");
         let res = node_0
-            .send_mpp_payment_with_dry_run_option(&node_2, amount, None, true)
+            .send_mpp_payment_with_dry_run_option(&node_2, amount, None, true, MppMode::BasicMpp)
             .await;
 
         if let Some(count) = expect_routers_count {
@@ -2194,7 +2193,7 @@ async fn test_send_mpp_will_succeed_with_retry_first_hops() {
     let [node_0, node_1] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2249,7 +2248,7 @@ async fn test_send_mpp_will_succeed_with_retry_2_channels() {
     let [node_0, node_1] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2306,7 +2305,7 @@ async fn test_send_mpp_will_fail_with_retry_3_channels() {
     let [node_0, node_1] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2352,7 +2351,7 @@ async fn test_send_mpp_will_success_with_retry_split_channels() {
     let [node_0, node_1] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_1, 300000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2398,7 +2397,7 @@ async fn test_send_mpp_will_fail_with_disable_single_path() {
     let [node_0, _node_1, node_2] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_2, 30000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_2, 30000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2449,7 +2448,7 @@ async fn test_send_mpp_will_success_with_middle_hop_capacity_not_enough() {
     let [node_0, _node_1, node_2] = nodes.try_into().expect("ok nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_2, 300000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_2, 300000, None, true, MppMode::BasicMpp)
         .await;
 
     let query_res = res.unwrap();
@@ -2494,9 +2493,9 @@ async fn test_send_mpp_will_success_with_same_payment_after_restarted() {
         3,
     )
     .await;
-    let [node_0, mut node_1, mut node_2] = nodes.try_into().expect("ok nodes");
+    let [node_0, mut node_1, node_2] = nodes.try_into().expect("ok nodes");
 
-    let target_node = &mut node_2;
+    let target_node = &node_2;
     let amount = 300000;
     let target_pubkey = target_node.get_public_key();
     let preimage = gen_rand_sha256_hash();
@@ -2504,7 +2503,7 @@ async fn test_send_mpp_will_success_with_same_payment_after_restarted() {
         .amount(Some(amount))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -2573,8 +2572,8 @@ async fn test_mpp_tlc_set_without_invoice_should_not_be_accepted() {
             2,
         )
         .await;
-        let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
-        let source_node = &mut node_0;
+        let [node_0, node_1] = nodes.try_into().expect("2 nodes");
+        let source_node = &node_0;
         let target_pubkey = node_1.pubkey;
 
         let payment_secret = gen_rand_sha256_hash();
@@ -2681,9 +2680,9 @@ async fn test_send_payment_with_invoice_removed_from_last_hop() {
         3,
     )
     .await;
-    let [node_0, _node_1, mut node_2] = nodes.try_into().expect("ok nodes");
+    let [node_0, _node_1, node_2] = nodes.try_into().expect("ok nodes");
 
-    let target_node = &mut node_2;
+    let target_node = &node_2;
     let amount = 300000;
     let target_pubkey = target_node.get_public_key();
     let preimage = gen_rand_sha256_hash();
@@ -2691,7 +2690,7 @@ async fn test_send_payment_with_invoice_removed_from_last_hop() {
         .amount(Some(amount))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -2737,7 +2736,7 @@ async fn test_mpp_tlc_with_invoice_not_allow_mpp_should_not_be_accepted() {
         .amount(Some(20000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -3212,6 +3211,7 @@ async fn test_send_payment_custom_records_not_in_range() {
                 max_parts: Some(2),
                 ..Default::default()
             },
+            MppMode::BasicMpp,
         )
         .await;
 
@@ -3237,7 +3237,13 @@ async fn test_mpp_can_not_find_path_filter_target_node_features() {
     let [mut node_0, node_1] = nodes.try_into().expect("2 nodes");
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 20000000000, Some(2), true)
+        .send_mpp_payment_with_dry_run_option(
+            &node_1,
+            20000000000,
+            Some(2),
+            true,
+            MppMode::BasicMpp,
+        )
         .await;
     eprintln!("query res: {:?}", res);
 
@@ -3251,7 +3257,13 @@ async fn test_mpp_can_not_find_path_filter_target_node_features() {
         .await;
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_1, 20000000000, Some(2), true)
+        .send_mpp_payment_with_dry_run_option(
+            &node_1,
+            20000000000,
+            Some(2),
+            true,
+            MppMode::BasicMpp,
+        )
         .await;
     eprintln!("query res: {:?}", res);
 
@@ -3281,7 +3293,7 @@ async fn test_mpp_fail_on_total_amount_not_match() {
         .amount(Some(15000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -3361,6 +3373,7 @@ async fn test_mpp_can_not_find_path_filter_middle_node_features() {
                 200 * CKB_SHANNONS as u128,
                 Some(2),
                 true,
+                MppMode::BasicMpp,
             )
             .await;
         eprintln!("query res: {:?}", res);
@@ -3391,6 +3404,7 @@ async fn test_mpp_can_not_find_path_filter_middle_node_features() {
                 200 * CKB_SHANNONS as u128,
                 Some(2),
                 true,
+                MppMode::BasicMpp,
             )
             .await;
         eprintln!("query res: {:?}", res);
@@ -3550,7 +3564,7 @@ async fn test_send_3_nodes_pay_self() {
         .amount(Some(amount))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build()
         .expect("build invoice success");
@@ -3627,14 +3641,14 @@ async fn test_send_mpp_respect_min_tlc_value() {
     assert!(res.is_ok());
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_2, 28000, Some(3), true)
+        .send_mpp_payment_with_dry_run_option(&node_2, 28000, Some(3), true, MppMode::BasicMpp)
         .await;
 
     eprintln!("res: {:?}", res);
     assert!(res.is_err());
 
     let res = node_0
-        .send_mpp_payment_with_dry_run_option(&node_2, 30000, None, true)
+        .send_mpp_payment_with_dry_run_option(&node_2, 30000, None, true, MppMode::BasicMpp)
         .await;
     debug!("res: {:?}", res);
     assert!(res.is_ok());
@@ -3659,8 +3673,8 @@ async fn test_send_mpp_can_retry() {
     )
     .await;
     let [node_0, node_1, _node_2, node_3] = nodes.try_into().expect("4 nodes");
-    let res = node_0.send_mpp_payment(&node_3, 30000000000, Some(3)).await;
     node_1.disable_channel_stealthy(channels[3]).await;
+    let res = node_0.send_mpp_payment(&node_3, 30000000000, Some(3)).await;
 
     tokio::time::sleep(Duration::from_secs(1)).await;
     eprintln!("res: {:?}", res);
diff --git a/crates/fiber-lib/src/fiber/tests/payment.rs b/crates/fiber-lib/src/fiber/tests/payment.rs
index 33f23b150..f13f6ec52 100644
--- a/crates/fiber-lib/src/fiber/tests/payment.rs
+++ b/crates/fiber-lib/src/fiber/tests/payment.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::needless_range_loop)]
+use crate::fiber::builtin_records::BasicMppPaymentData;
 use crate::fiber::channel::*;
 use crate::fiber::config::DEFAULT_FINAL_TLC_EXPIRY_DELTA;
 use crate::fiber::config::DEFAULT_TLC_EXPIRY_DELTA;
@@ -3151,11 +3152,10 @@ async fn test_send_payment_middle_hop_balance_is_not_enough() {
     // 2 -> 3 don't have enough balance
     node_0.wait_until_failed(res.payment_hash).await;
     let result = node_0.get_payment_result(res.payment_hash).await;
-    eprintln!("debug result: {:?}", result);
     assert!(result
         .failed_error
         .expect("got error")
-        .contains("Failed to build route"));
+        .contains("PathFind error: no path found"));
 }
 
 #[tokio::test]
@@ -5005,6 +5005,7 @@ async fn test_send_payment_no_preimage_invoice_will_make_payment_failed() {
                 max_fee_amount: None,
                 max_parts: None,
                 keysend: None,
+                atomic_mpp: None,
                 udt_type_script: None,
                 dry_run: false,
                 hop_hints: None,
@@ -5558,7 +5559,7 @@ async fn test_payment_with_payment_data_record() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(true)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -5659,7 +5660,7 @@ async fn test_payment_with_insufficient_total_amount() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -5785,7 +5786,7 @@ async fn test_payment_with_wrong_payment_secret() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -5899,7 +5900,7 @@ async fn test_payment_with_insufficient_amount_with_payment_data() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -6012,7 +6013,7 @@ async fn test_payment_with_insufficient_amount_without_payment_data() {
         .amount(Some(10000000000))
         .payment_preimage(preimage)
         .payee_pub_key(target_pubkey.into())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .payment_secret(payment_secret)
         .build()
         .expect("build invoice success");
@@ -6524,3 +6525,103 @@ async fn test_send_payment_two_with_same_invoice() {
     }
     assert_eq!(succeeded_count, 1);
 }
+
+#[tokio::test]
+async fn test_send_payment_3_nodes_failed_last_hop() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        3,
+    )
+    .await;
+    let [node_0, mut node_1, mut node_2] = nodes.try_into().expect("3 nodes");
+    node_1
+        .expect_event(|event| match event {
+            NetworkServiceEvent::DebugEvent(DebugEvent::Common(msg)) => {
+                msg.starts_with("Channel is now ready")
+            }
+            _ => false,
+        })
+        .await;
+
+    node_2.stop().await;
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    let payment = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_2.pubkey),
+            amount: Some(100),
+            keysend: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    node_0
+        .wait_until_failed(payment.unwrap().payment_hash)
+        .await;
+
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    node_2.start().await;
+
+    node_1
+        .expect_event(|event| match event {
+            NetworkServiceEvent::DebugEvent(DebugEvent::Common(msg)) => {
+                msg.starts_with("Channel is now ready")
+            }
+            _ => false,
+        })
+        .await;
+
+    node_0.clear_history().await;
+
+    let payment = node_0
+        .send_payment(SendPaymentCommand {
+            target_pubkey: Some(node_2.pubkey),
+            amount: Some(100),
+            keysend: Some(true),
+            ..Default::default()
+        })
+        .await;
+
+    debug!("payment: {:?}", payment);
+    node_0
+        .wait_until_success(payment.unwrap().payment_hash)
+        .await;
+}
+
+#[tokio::test]
+async fn test_send_payment_mpp_can_not_be_keysend() {
+    init_tracing();
+
+    let (nodes, _channels) = create_n_nodes_network(
+        &[
+            ((0, 1), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+            ((1, 2), (MIN_RESERVED_CKB + 10000000000, MIN_RESERVED_CKB)),
+        ],
+        3,
+    )
+    .await;
+    let [node_0, _node_1, node_2] = nodes.try_into().expect("3 nodes");
+    let node_2_pubkey = node_2.pubkey;
+    let res = node_0
+        .send_mpp_payment_with_command(
+            &node_2,
+            100,
+            SendPaymentCommand {
+                target_pubkey: Some(node_2_pubkey),
+                keysend: Some(true),
+                allow_self_payment: false,
+                dry_run: false,
+                ..Default::default()
+            },
+            MppMode::BasicMpp,
+        )
+        .await;
+    eprintln!("res: {:?}", res);
+    assert!(res
+        .unwrap_err()
+        .contains("keysend payment should not have invoice"));
+}
diff --git a/crates/fiber-lib/src/fiber/tests/rpc.rs b/crates/fiber-lib/src/fiber/tests/rpc.rs
index 54e1ff9b7..e1a56923e 100644
--- a/crates/fiber-lib/src/fiber/tests/rpc.rs
+++ b/crates/fiber-lib/src/fiber/tests/rpc.rs
@@ -6,6 +6,7 @@ use crate::gen_rand_sha256_hash;
 use crate::invoice::CkbInvoice;
 use crate::rpc::channel::{ChannelState, ShutdownChannelParams};
 use crate::rpc::config::RpcConfig;
+use crate::rpc::graph::{GraphChannelsParams, GraphChannelsResult};
 use crate::rpc::info::NodeInfoResult;
 use crate::tests::*;
 use crate::{
@@ -31,9 +32,8 @@ fn rpc_config_with_auth() -> (RpcConfig, KeyPair) {
     (config, root)
 }
 
-#[tokio::test]
-async fn test_rpc_basic() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
+async fn gen_mock_network() -> (Vec<NetworkNode>, Vec<Hash256>) {
+    create_n_nodes_network_with_params(
         &[
             (
                 (0, 1),
@@ -57,7 +57,13 @@ async fn test_rpc_basic() {
         2,
         Some(gen_rpc_config()),
     )
-    .await;
+    .await
+}
+
+#[tokio::test]
+async fn test_rpc_basic() {
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, node_1] = nodes.try_into().expect("2 nodes");
 
     let res: ListChannelsResult = node_0
@@ -99,6 +105,7 @@ async fn test_rpc_basic() {
         payment_hash: None,
         hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
         allow_mpp: Some(true),
+        allow_atomic_mpp: None,
     };
 
     // node0 generate a invoice
@@ -144,13 +151,13 @@ async fn test_rpc_basic() {
         description: Some("test".to_string()),
         currency: Currency::Fibd,
         expiry: Some(322),
-        fallback_address: None,
         final_expiry_delta: Some(900000 + 1234),
         udt_type_script: Some(Script::default().into()),
         payment_preimage: Some(gen_rand_sha256_hash()),
         payment_hash: None,
         hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
         allow_mpp: Some(false),
+        ..Default::default()
     };
 
     // node0 generate a invoice
@@ -163,6 +170,68 @@ async fn test_rpc_basic() {
     assert!(internal_ckb_invoice.payment_secret().is_none());
 }
 
+#[tokio::test]
+async fn test_invoice_rpc() {
+    let (nodes, _channels) = gen_mock_network().await;
+
+    let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
+
+    let payment_hash = gen_rand_sha256_hash();
+    let new_invoice_params = NewInvoiceParams {
+        amount: 1000,
+        description: Some("test".to_string()),
+        currency: Currency::Fibd,
+        expiry: Some(322),
+        final_expiry_delta: Some(900000 + 1234),
+        udt_type_script: Some(Script::default().into()),
+        payment_hash: Some(payment_hash),
+        hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
+        allow_atomic_mpp: Some(true),
+        ..Default::default()
+    };
+
+    // node0 generate a invoice
+    let invoice_res: InvoiceResult = node_0
+        .send_rpc_request("new_invoice", new_invoice_params)
+        .await
+        .unwrap();
+
+    let ckb_invoice = invoice_res.invoice.clone();
+    let invoice_payment_hash = ckb_invoice.data.payment_hash;
+    assert_eq!(invoice_payment_hash, payment_hash);
+    assert!(node_0.get_payment_preimage(&payment_hash).is_none());
+}
+
+#[tokio::test]
+async fn test_invoice_rpc_invalid_mpp_option() {
+    let (nodes, _channels) = gen_mock_network().await;
+
+    let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
+
+    let payment_hash = gen_rand_sha256_hash();
+    let new_invoice_params = NewInvoiceParams {
+        amount: 1000,
+        description: Some("test".to_string()),
+        currency: Currency::Fibd,
+        expiry: Some(322),
+        final_expiry_delta: Some(900000 + 1234),
+        udt_type_script: Some(Script::default().into()),
+        payment_hash: Some(payment_hash),
+        hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
+        allow_mpp: Some(true),
+        allow_atomic_mpp: Some(true),
+        ..Default::default()
+    };
+
+    // node0 generate a invoice
+    let invoice_res: Result<InvoiceResult, String> = node_0
+        .send_rpc_request("new_invoice", new_invoice_params)
+        .await;
+
+    let err = invoice_res.unwrap_err();
+    assert!(err.contains("Can not set both basic MPP and atomic MPP"));
+}
+
 #[tokio::test]
 async fn test_rpc_list_peers() {
     let (nodes, _channels) = create_n_nodes_network_with_params(
@@ -241,31 +310,7 @@ async fn test_rpc_list_peers() {
 
 #[tokio::test]
 async fn test_rpc_graph() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
     let [node_0, node_1] = nodes.try_into().expect("2 nodes");
 
     let graph_nodes: GraphNodesResult = node_0
@@ -288,35 +333,25 @@ async fn test_rpc_graph() {
         .iter()
         .all(|n| n.version == *env!("CARGO_PKG_VERSION")));
     assert!(!graph_nodes.nodes[0].features.is_empty());
+
+    let graph_channels: GraphChannelsResult = node_0
+        .send_rpc_request(
+            "graph_channels",
+            GraphChannelsParams {
+                limit: None,
+                after: None,
+            },
+        )
+        .await
+        .unwrap();
+
+    assert_eq!(graph_channels.channels.len(), 2);
 }
 
 #[tokio::test]
 async fn test_rpc_shutdown_channels() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
 
     let list_channels: ListChannelsResult = node_0
@@ -415,31 +450,8 @@ async fn test_rpc_shutdown_channels() {
 
 #[tokio::test]
 async fn test_rpc_node_info() {
-    let (nodes, _channels) = create_n_nodes_network_with_params(
-        &[
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-            (
-                (0, 1),
-                ChannelParameters {
-                    public: true,
-                    node_a_funding_amount: MIN_RESERVED_CKB + 10000000000,
-                    node_b_funding_amount: MIN_RESERVED_CKB,
-                    ..Default::default()
-                },
-            ),
-        ],
-        2,
-        Some(gen_rpc_config()),
-    )
-    .await;
+    let (nodes, _channels) = gen_mock_network().await;
+
     let [node_0, _node_1] = nodes.try_into().expect("2 nodes");
 
     let node_info: NodeInfoResult = node_0.send_rpc_request("node_info", ()).await.unwrap();
@@ -536,13 +548,12 @@ async fn test_rpc_basic_with_auth() {
                 description: Some("test".to_string()),
                 currency: Currency::Fibd,
                 expiry: Some(322),
-                fallback_address: None,
                 final_expiry_delta: Some(900000 + 1234),
                 udt_type_script: Some(Script::default().into()),
                 payment_preimage: Some(Hash256::default()),
                 payment_hash: None,
                 hash_algorithm: Some(crate::fiber::hash_algorithm::HashAlgorithm::CkbHash),
-                allow_mpp: None,
+                ..Default::default()
             },
         )
         .await
diff --git a/crates/fiber-lib/src/fiber/tests/tlc_op.rs b/crates/fiber-lib/src/fiber/tests/tlc_op.rs
index 160013f17..4425e9caa 100644
--- a/crates/fiber-lib/src/fiber/tests/tlc_op.rs
+++ b/crates/fiber-lib/src/fiber/tests/tlc_op.rs
@@ -210,6 +210,7 @@ impl Actor for TlcActor {
                     tlc_id: TLCId::Offered(next_offer_id),
                     amount: command.amount,
                     payment_hash: command.payment_hash,
+                    parent_payment_hash: None,
                     attempt_id: command.attempt_id,
                     expiry: command.expiry,
                     hash_algorithm: command.hash_algorithm,
@@ -479,6 +480,7 @@ fn test_tlc_state_v2() {
         status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
         channel_id: gen_rand_sha256_hash(),
         payment_hash: gen_rand_sha256_hash(),
+        parent_payment_hash: None,
         attempt_id: None,
         expiry: now_timestamp_as_millis_u64() + 1000,
         hash_algorithm: HashAlgorithm::Sha256,
@@ -499,6 +501,7 @@ fn test_tlc_state_v2() {
         status: TlcStatus::Outbound(OutboundTlcStatus::LocalAnnounced),
         channel_id: gen_rand_sha256_hash(),
         payment_hash: gen_rand_sha256_hash(),
+        parent_payment_hash: None,
         attempt_id: None,
         expiry: now_timestamp_as_millis_u64() + 2000,
         hash_algorithm: HashAlgorithm::Sha256,
diff --git a/crates/fiber-lib/src/fiber/tests/types.rs b/crates/fiber-lib/src/fiber/tests/types.rs
index 989a8dc91..89bcb2b70 100644
--- a/crates/fiber-lib/src/fiber/tests/types.rs
+++ b/crates/fiber-lib/src/fiber/tests/types.rs
@@ -1,15 +1,16 @@
 use crate::{
     ckb::config::{UdtArgInfo, UdtCellDep, UdtCfgInfos, UdtDep, UdtScript},
     fiber::{
+        amp::{AmpChild, AmpChildDesc, AmpSecret},
+        builtin_records::{AmpPaymentData, BasicMppPaymentData},
         config::AnnouncedNodeName,
         features::FeatureVector,
         gen::{fiber as molecule_fiber, gossip},
         hash_algorithm::HashAlgorithm,
         types::{
-            pack_hop_data, secp256k1_instance, unpack_hop_data, AddTlc, BasicMppPaymentData,
-            BroadcastMessageID, Cursor, Hash256, NodeAnnouncement, NodeId, PaymentHopData,
-            PeeledPaymentOnionPacket, Privkey, Pubkey, TlcErr, TlcErrPacket, TlcErrorCode,
-            NO_SHARED_SECRET,
+            pack_hop_data, secp256k1_instance, unpack_hop_data, AddTlc, BroadcastMessageID, Cursor,
+            Hash256, NodeAnnouncement, NodeId, PaymentHopData, PeeledPaymentOnionPacket, Privkey,
+            Pubkey, TlcErr, TlcErrPacket, TlcErrorCode, NO_SHARED_SECRET,
         },
         PaymentCustomRecords,
     },
@@ -30,7 +31,7 @@ use serde::Deserialize;
 use serde::Serialize;
 use tentacle::{multiaddr::MultiAddr, secio::PeerId};
 
-use std::str::FromStr;
+use std::{collections::HashSet, str::FromStr};
 
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
 #[cfg_attr(not(target_arch = "wasm32"), test)]
@@ -534,13 +535,13 @@ fn test_verify_hard_coded_node_announcement() {
 
     for (signature, message, node_announcement) in [
         (
-            "80a0e9d4ed35eb76e086038983dfd2572e7298a795b4cde7b113d805eeb495192cf552e4cc631e73fee76c4f0479a33327488f8a99978a10e2583b7faba2cf61",
-            "044e5172e9a9d7b383c15f40d8dac30f86422e7082af2b4d7db7f5484b4a1701",
+            "cfe5d1dde285bac326fb290899c14bd05b9afa013c61c3c9338daca07ab0d287647c2101482bc193913b91da0e9284ebd352f1139149b8943876c78ff46608fc",
+            "e387e01002f45594d36577ac53c822f8712b378ed52e8dde3bfbdb3b01b29abc",
             node1(),
         ),
         (
-            "3a1eea2e372e5c3bc53d1c283d449afbfff029308fe59e111a23ad32163d2a6f58128e21083e128a05d34fb8c0068a1f4fa6e4ae12e370d3051591df151a957a",
-            "db96ac7278d1db7b03eefdc4d21c952e3aee8a4be87a82c8c0e66a87e8897a81",
+            "1fec23d92c9fc9fafd39f477bf1fbb79cfb8f63604a6aeb0712cfd7dbe31e4e21a174f4e6733e78970f4489859aa1ba615fe712d4d212dd7f1c1a6678dff5d00",
+            "3e612fcfa66885352ac18e1fdd602199fb125fa4435ea509f472c0c870b0d307",
             node2(),
         ),
     ] {
@@ -729,3 +730,186 @@ fn test_basic_mpp_custom_records() {
     let new_record = BasicMppPaymentData::read(&payment_custom_records).unwrap();
     assert_eq!(new_record, record);
 }
+
+#[test]
+fn test_amp_custom_records() {
+    let mut payment_custom_records = PaymentCustomRecords::default();
+    let parent_payment_hash = gen_rand_sha256_hash();
+    let amp_record = AmpPaymentData::new(
+        parent_payment_hash,
+        3,
+        AmpChildDesc::new(0, AmpSecret::random()),
+        1000,
+    );
+    amp_record.write(&mut payment_custom_records);
+
+    let new_amp_record = AmpPaymentData::read(&payment_custom_records).unwrap();
+    assert_eq!(new_amp_record, amp_record);
+}
+
+#[test]
+fn test_share_xor() {
+    let share1 = AmpSecret::random();
+    let share2 = AmpSecret::random();
+    let result = share1.xor(&share2);
+
+    // XOR is commutative
+    assert_eq!(result, share2.xor(&share1));
+
+    // XOR with self should be zero
+    assert_eq!(share1.xor(&share1), AmpSecret::zero());
+}
+
+#[test]
+fn test_derive_child() {
+    let root = AmpSecret::random();
+    let share = AmpSecret::random();
+
+    let amp_data = AmpChildDesc::new(4, share);
+    let child = AmpChild::derive_child(root, amp_data.clone(), HashAlgorithm::Sha256);
+
+    assert_ne!(child.preimage, Hash256::default());
+    assert_ne!(child.hash, Hash256::default());
+
+    // Deriving the same child should produce the same result
+    let child2 = AmpChild::derive_child(root, amp_data, HashAlgorithm::Sha256);
+    assert_eq!(child, child2);
+}
+
+#[test]
+fn test_different_indices_produce_different_children() {
+    let root = AmpSecret::random();
+    let share = AmpSecret::random();
+
+    let child1 = AmpChild::derive_child(root, AmpChildDesc::new(0, share), HashAlgorithm::Sha256);
+    let child2 = AmpChild::derive_child(root, AmpChildDesc::new(1, share), HashAlgorithm::Sha256);
+
+    assert_ne!(child1.preimage, child2.preimage);
+    assert_ne!(child1.hash, child2.hash);
+}
+
+#[test]
+fn test_reconstruct_children() {
+    let root = AmpSecret::random();
+    let share1 = AmpSecret::random();
+    let share2 = root.xor(&share1); // share2 = root ^ share1
+
+    let desc1 = AmpChildDesc::new(0, share1);
+    let desc2 = AmpChildDesc::new(1, share2);
+
+    let children =
+        AmpChild::reconstruct_amp_children(&[desc1.clone(), desc2.clone()], HashAlgorithm::Sha256);
+
+    assert_eq!(children.len(), 2);
+
+    // Verify that the children are correctly derived from the reconstructed root
+    let expected_child1 = AmpChild::derive_child(root, desc1, HashAlgorithm::Sha256);
+    let expected_child2 = AmpChild::derive_child(root, desc2, HashAlgorithm::Sha256);
+
+    assert_eq!(children[0], expected_child1);
+    assert_eq!(children[1], expected_child2);
+}
+
+#[test]
+fn test_reconstruct_single_child() {
+    let root = AmpSecret::random();
+    let share = root;
+    let desc = AmpChildDesc::new(0, share);
+
+    let children = AmpChild::reconstruct_amp_children(&[desc.clone()], HashAlgorithm::Sha256);
+
+    assert_eq!(children.len(), 1);
+
+    // Verify that the child is correctly derived from the reconstructed root
+    let expected_child = AmpChild::derive_child(root, desc, HashAlgorithm::Sha256);
+    assert_eq!(children[0], expected_child);
+}
+
+#[test]
+fn test_reconstruct_n_children() {
+    let root = AmpSecret::random();
+    let shares = AmpSecret::gen_random_sequence(root, 100);
+    let descs: Vec<AmpChildDesc> = shares
+        .iter()
+        .enumerate()
+        .map(|(i, &share)| AmpChildDesc::new(i as u16, share))
+        .collect();
+
+    // last hop will reconstruct children and derive them
+    let children = AmpChild::reconstruct_amp_children(&descs.clone(), HashAlgorithm::Sha256);
+
+    assert_eq!(children.len(), descs.len());
+
+    // Verify that each child is correctly derived from the reconstructed root
+    for (i, desc) in descs.iter().enumerate() {
+        let expected_child = AmpChild::derive_child(root, desc.clone(), HashAlgorithm::Sha256);
+        assert_eq!(children[i], expected_child);
+    }
+
+    // if we only reconstruct the first 10 children, they should not be the same
+    let first_10_children = &descs[0..10];
+    let children = AmpChild::reconstruct_amp_children(first_10_children, HashAlgorithm::Sha256);
+
+    // the derived child is not equal to expected child
+    for (i, desc) in first_10_children.iter().enumerate() {
+        let expected_child = AmpChild::derive_child(root, desc.clone(), HashAlgorithm::Sha256);
+        assert_ne!(children[i], expected_child);
+    }
+}
+
+#[test]
+fn test_reconstruct_empty_children() {
+    let children = AmpChild::reconstruct_amp_children(&[], HashAlgorithm::Sha256);
+    assert!(children.is_empty());
+}
+
+#[test]
+fn test_part_of_attempt_retry() {
+    let root = AmpSecret::random();
+    let shares = AmpSecret::gen_random_sequence(root, 5);
+    let descs: Vec<AmpChildDesc> = shares
+        .iter()
+        .enumerate()
+        .map(|(i, &share)| AmpChildDesc::new(i as u16, share))
+        .collect();
+
+    let children = AmpChild::reconstruct_amp_children(&descs.clone(), HashAlgorithm::Sha256);
+
+    assert_eq!(children.len(), descs.len());
+
+    let retried_index = [1, 2];
+    let new_attempts_count = 9;
+
+    let old_descs: Vec<_> = descs
+        .iter()
+        .filter(|d| !retried_index.contains(&d.index))
+        .cloned()
+        .collect();
+
+    let mut new_root_share = AmpSecret::zero();
+    let removed_descs: Vec<_> = descs
+        .iter()
+        .filter(|d| retried_index.contains(&d.index))
+        .collect();
+    for d in removed_descs.iter() {
+        new_root_share = new_root_share.xor(&d.secret);
+    }
+
+    let old_index: HashSet<u16> = old_descs.iter().map(|d| d.index).collect();
+    let all_index: HashSet<u16> = (0..new_attempts_count as u16).collect();
+
+    let mut new_descs = old_descs.clone();
+    let new_indexes: Vec<_> = all_index.difference(&old_index).collect();
+    let new_shares = AmpSecret::gen_random_sequence(new_root_share, new_indexes.len() as u16);
+    for (i, share) in new_indexes.iter().zip(new_shares.iter()) {
+        let desc = AmpChildDesc::new(**i, *share);
+        new_descs.push(desc);
+    }
+
+    // Verify that each child is correctly derived from the reconstructed root
+    let mut original_root_share = AmpSecret::zero();
+    for a in new_descs.iter() {
+        original_root_share = original_root_share.xor(&a.secret);
+    }
+    assert_eq!(original_root_share, root);
+}
diff --git a/crates/fiber-lib/src/fiber/types.rs b/crates/fiber-lib/src/fiber/types.rs
index e8dd60c7a..66c59478c 100644
--- a/crates/fiber-lib/src/fiber/types.rs
+++ b/crates/fiber-lib/src/fiber/types.rs
@@ -12,12 +12,16 @@ use super::r#gen::fiber::PubNonceOpt;
 use super::serde_utils::{EntityHex, PubNonceAsBytes, SliceBase58, SliceHex};
 use crate::ckb::config::{UdtArgInfo, UdtCellDep, UdtCfgInfos, UdtDep, UdtScript};
 use crate::ckb::contracts::get_udt_whitelist;
-use crate::fiber::network::USER_CUSTOM_RECORDS_MAX_INDEX;
+use crate::fiber::builtin_records::{AmpPaymentData, BasicMppPaymentData};
+use ckb_jsonrpc_types::CellOutput;
+use ckb_types::H256;
+use num_enum::IntoPrimitive;
+use num_enum::TryFromPrimitive;
+use std::convert::TryFrom;
+use std::fmt::Debug;
 
 use anyhow::anyhow;
 use bitcoin::hashes::Hash;
-use ckb_jsonrpc_types::CellOutput;
-use ckb_types::H256;
 use ckb_types::{
     core::FeeRate,
     packed::{Byte32 as MByte32, BytesVec, OutPoint, Script, Transaction},
@@ -28,8 +32,6 @@ use fiber_sphinx::{OnionErrorPacket, SphinxError};
 use molecule::prelude::{Builder, Byte, Entity};
 use musig2::secp::{Point, Scalar};
 use musig2::{BinaryEncoding, PartialSignature, PubNonce};
-use num_enum::IntoPrimitive;
-use num_enum::TryFromPrimitive;
 use once_cell::sync::OnceCell;
 use ractor::concurrency::Duration;
 use secp256k1::{
@@ -40,8 +42,6 @@ use secp256k1::{Verification, XOnlyPublicKey};
 use serde::{Deserialize, Serialize};
 use serde_with::serde_as;
 use std::cmp::Ordering;
-use std::convert::TryFrom;
-use std::fmt::Debug;
 use std::fmt::Display;
 use std::str::FromStr;
 use strum::{AsRefStr, EnumString};
@@ -3683,55 +3683,6 @@ impl_traits!(FiberMessage);
 pub(crate) fn deterministically_hash<T: Entity>(v: &T) -> [u8; 32] {
     ckb_hash::blake2b_256(v.as_slice())
 }
-
-#[derive(Eq, PartialEq, Debug)]
-/// Bolt04 basic MPP payment data record
-pub struct BasicMppPaymentData {
-    pub payment_secret: Hash256,
-    pub total_amount: u128,
-}
-
-impl BasicMppPaymentData {
-    // record type for payment data record in bolt04
-    // custom records key from 65536 is reserved for internal usage
-    pub const CUSTOM_RECORD_KEY: u32 = USER_CUSTOM_RECORDS_MAX_INDEX + 1;
-
-    pub fn new(payment_secret: Hash256, total_amount: u128) -> Self {
-        Self {
-            payment_secret,
-            total_amount,
-        }
-    }
-
-    fn to_vec(&self) -> Vec<u8> {
-        let mut vec = Vec::new();
-        vec.extend_from_slice(self.payment_secret.as_ref());
-        vec.extend_from_slice(&self.total_amount.to_le_bytes());
-        vec
-    }
-
-    pub fn write(&self, custom_records: &mut PaymentCustomRecords) {
-        custom_records
-            .data
-            .insert(Self::CUSTOM_RECORD_KEY, self.to_vec());
-    }
-
-    pub fn read(custom_records: &PaymentCustomRecords) -> Option<Self> {
-        custom_records
-            .data
-            .get(&Self::CUSTOM_RECORD_KEY)
-            .and_then(|data| {
-                if data.len() != 32 + 16 {
-                    return None;
-                }
-                let secret: [u8; 32] = data[..32].try_into().unwrap();
-                let payment_secret = Hash256::from(secret);
-                let total_amount = u128::from_le_bytes(data[32..].try_into().unwrap());
-                Some(Self::new(payment_secret, total_amount))
-            })
-    }
-}
-
 #[serde_as]
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct PaymentHopData {
@@ -3902,12 +3853,19 @@ pub struct PeeledPaymentOnionPacket {
 }
 
 impl PeeledPaymentOnionPacket {
-    pub fn mpp_custom_records(&self) -> Option<BasicMppPaymentData> {
+    pub fn basic_mpp_custom_records(&self) -> Option<BasicMppPaymentData> {
         self.current
             .custom_records
             .as_ref()
             .and_then(BasicMppPaymentData::read)
     }
+
+    pub fn atomic_mpp_custom_records(&self) -> Option<AmpPaymentData> {
+        self.current
+            .custom_records
+            .as_ref()
+            .and_then(AmpPaymentData::read)
+    }
 }
 
 impl PaymentOnionPacket {
@@ -4125,7 +4083,7 @@ impl ::std::str::FromStr for NodeId {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq, Hash)]
 pub struct HoldTlc {
     pub channel_id: Hash256,
     pub tlc_id: u64,
diff --git a/crates/fiber-lib/src/invoice/errors.rs b/crates/fiber-lib/src/invoice/errors.rs
index 89347decd..891a68043 100644
--- a/crates/fiber-lib/src/invoice/errors.rs
+++ b/crates/fiber-lib/src/invoice/errors.rs
@@ -47,12 +47,14 @@ pub enum InvoiceError {
     DuplicatedAttributeKey(String),
     #[error("Payment secret is required for MPP payments")]
     PaymentSecretRequiredForMpp,
-    /// Both set payment_hash and payment_preimage
-    #[error("Both payment_hash and payment_preimage are set")]
-    BothPaymenthashAndPreimage,
+    #[error("Can not set both basic MPP and atomic MPP")]
+    BothBasicMPPAndAtomicMPP,
     /// Neither payment_hash nor payment_preimage is set
     #[error("Neither payment_hash nor payment_preimage is set")]
     NeitherPaymenthashNorPreimage,
+    /// Both set payment_hash and payment_preimage
+    #[error("Both payment_hash and payment_preimage are set")]
+    BothPaymenthashAndPreimage,
     /// An error occurred during signing
     #[error("Sign error")]
     SignError,
diff --git a/crates/fiber-lib/src/invoice/invoice_impl.rs b/crates/fiber-lib/src/invoice/invoice_impl.rs
index 23c381767..ef2d4d90d 100644
--- a/crates/fiber-lib/src/invoice/invoice_impl.rs
+++ b/crates/fiber-lib/src/invoice/invoice_impl.rs
@@ -3,6 +3,7 @@ use super::utils::*;
 use crate::fiber::features::FeatureVector;
 use crate::fiber::gen::invoice::{self as gen_invoice, *};
 use crate::fiber::hash_algorithm::HashAlgorithm;
+use crate::fiber::payment::MppMode;
 use crate::fiber::serde_utils::{duration_hex, EntityHex, U128Hex, U64Hex};
 use crate::fiber::types::Hash256;
 use crate::invoice::InvoiceError;
@@ -348,11 +349,32 @@ impl CkbInvoice {
     attr_getter!(hash_algorithm, HashAlgorithm, HashAlgorithm);
     attr_getter!(payment_secret, PaymentSecret, Hash256);
 
-    pub fn allow_mpp(&self) -> bool {
+    fn has_feature<F>(&self, feature_check: F) -> bool
+    where
+        F: Fn(&FeatureVector) -> bool,
+    {
         self.data
             .attrs
             .iter()
-            .any(|attr| matches!(attr, Attribute::Feature(feature) if feature.supports_basic_mpp()))
+            .any(|attr| matches!(attr, Attribute::Feature(feature) if feature_check(feature)))
+    }
+
+    pub fn basic_mpp(&self) -> bool {
+        self.has_feature(|feature| feature.supports_basic_mpp())
+    }
+
+    pub fn atomic_mpp(&self) -> bool {
+        self.has_feature(|feature| feature.supports_atomic_mpp())
+    }
+
+    pub fn mpp_mode(&self) -> Option<MppMode> {
+        if self.basic_mpp() {
+            Some(MppMode::BasicMpp)
+        } else if self.atomic_mpp() {
+            Some(MppMode::AtomicMpp)
+        } else {
+            None
+        }
     }
 }
 
@@ -675,7 +697,10 @@ impl InvoiceBuilder {
     attr_setter!(payment_secret, PaymentSecret, Hash256);
     attr_setter!(hash_algorithm, HashAlgorithm, HashAlgorithm);
 
-    pub fn allow_mpp(self, allow_mpp: bool) -> Self {
+    fn update_feature_vector<F>(self, updater: F) -> Self
+    where
+        F: FnOnce(&mut FeatureVector),
+    {
         let mut feature_vector = self
             .attrs
             .iter()
@@ -688,14 +713,30 @@ impl InvoiceBuilder {
             })
             .unwrap_or_else(FeatureVector::new);
 
-        if allow_mpp {
-            feature_vector.set_basic_mpp_optional();
-        } else {
-            feature_vector.unset_basic_mpp_optional();
-        }
+        updater(&mut feature_vector);
         self.add_attr(Attribute::Feature(feature_vector))
     }
 
+    pub fn allow_basic_mpp(self, allow_mpp: bool) -> Self {
+        self.update_feature_vector(|feature_vector| {
+            if allow_mpp {
+                feature_vector.set_basic_mpp_optional();
+            } else {
+                feature_vector.unset_basic_mpp_optional();
+            }
+        })
+    }
+
+    pub fn allow_atomic_mpp(self, allow_atomic_mpp: bool) -> Self {
+        self.update_feature_vector(|feature_vector| {
+            if allow_atomic_mpp {
+                feature_vector.set_atomic_mpp_optional();
+            } else {
+                feature_vector.unset_atomic_mpp_optional();
+            }
+        })
+    }
+
     pub fn build(self) -> Result<CkbInvoice, InvoiceError> {
         let payment_hash: Hash256 = match (self.payment_hash, self.payment_preimage) {
             (Some(payment_hash), None) => payment_hash,
@@ -742,17 +783,23 @@ impl InvoiceBuilder {
     }
 
     fn check_attrs_valid(&self) -> Result<(), InvoiceError> {
-        let allow_mpp = self.attrs.iter().any(
+        let allow_basic_mpp = self.attrs.iter().any(
             |attr| matches!(attr, Attribute::Feature(feature) if feature.supports_basic_mpp()),
         );
+        let allow_atomic_mpp = self.attrs.iter().any(
+            |attr| matches!(attr, Attribute::Feature(feature) if feature.supports_atomic_mpp()),
+        );
         let payment_secret = self.attrs.iter().find_map(|attr| match attr {
             Attribute::PaymentSecret(secret) => Some(secret),
             _ => None,
         });
 
-        if allow_mpp && payment_secret.is_none() {
+        if allow_basic_mpp && payment_secret.is_none() {
             return Err(InvoiceError::PaymentSecretRequiredForMpp);
         }
+        if allow_basic_mpp && allow_atomic_mpp {
+            return Err(InvoiceError::BothBasicMPPAndAtomicMPP);
+        }
         // check is there any duplicate attribute key set
         for (i, attr) in self.attrs.iter().enumerate() {
             for other in self.attrs.iter().skip(i + 1) {
diff --git a/crates/fiber-lib/src/invoice/tests/invoice_impl.rs b/crates/fiber-lib/src/invoice/tests/invoice_impl.rs
index 8045d2e99..7e35861bb 100644
--- a/crates/fiber-lib/src/invoice/tests/invoice_impl.rs
+++ b/crates/fiber-lib/src/invoice/tests/invoice_impl.rs
@@ -492,7 +492,6 @@ fn test_invoice_builder_neither_payment_hash_nor_preimage() {
     let invoice = InvoiceBuilder::new(Currency::Fibb)
         .amount(Some(1280))
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key));
-
     assert_eq!(
         invoice.err(),
         Some(InvoiceError::NeitherPaymenthashNorPreimage)
@@ -576,41 +575,58 @@ fn test_invoice_with_mpp_option() {
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
         .unwrap();
 
-    assert!(!invoice.allow_mpp());
+    assert!(!invoice.basic_mpp());
 
     let invoice = InvoiceBuilder::new(Currency::Fibb)
         .amount(Some(1280))
         .payment_hash(gen_rand_sha256_hash())
-        .allow_mpp(true)
+        .allow_basic_mpp(true)
         .payment_secret(gen_rand_sha256_hash())
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
         .unwrap();
 
-    assert!(invoice.allow_mpp());
+    assert!(invoice.basic_mpp());
 
     let serialized_invoice = serde_json::to_string(&invoice).unwrap();
     eprintln!("Serialized invoice: {}", serialized_invoice);
     let deserialized_invoice: CkbInvoice =
         serde_json::from_str(&serialized_invoice).expect("Failed to deserialize invoice");
     assert_eq!(deserialized_invoice, invoice);
-    assert!(deserialized_invoice.allow_mpp());
+    assert!(deserialized_invoice.basic_mpp());
 
     let human_readable_invoice = invoice.to_string();
     let parsed_invoice: CkbInvoice = human_readable_invoice
         .parse()
         .expect("Failed to parse invoice");
     assert_eq!(parsed_invoice, invoice);
-    assert!(parsed_invoice.allow_mpp());
+    assert!(parsed_invoice.basic_mpp());
     assert!(parsed_invoice.payment_secret().is_some());
 
     let invoice = InvoiceBuilder::new(Currency::Fibb)
         .amount(Some(1280))
         .payment_hash(gen_rand_sha256_hash())
-        .allow_mpp(false)
+        .allow_basic_mpp(false)
         .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key))
         .unwrap();
 
-    assert!(!invoice.allow_mpp());
+    assert!(!invoice.basic_mpp());
     let payment_secret = invoice.payment_secret();
     assert!(payment_secret.is_none());
 }
+
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
+#[cfg_attr(not(target_arch = "wasm32"), test)]
+fn test_invoice_basic_mpp_and_atomic_mpp() {
+    let private_key = gen_rand_secp256k1_private_key();
+
+    let invoice = InvoiceBuilder::new(Currency::Fibb)
+        .amount(Some(1280))
+        .payment_hash(gen_rand_sha256_hash())
+        .allow_basic_mpp(true)
+        .allow_atomic_mpp(true)
+        .payment_secret(gen_rand_sha256_hash())
+        .build_with_sign(|hash| Secp256k1::new().sign_ecdsa_recoverable(hash, &private_key));
+
+    let err = invoice.unwrap_err();
+    assert_eq!(err, InvoiceError::BothBasicMPPAndAtomicMPP)
+}
diff --git a/crates/fiber-lib/src/rpc/README.md b/crates/fiber-lib/src/rpc/README.md
index cc1a8dae4..4b4da6e82 100644
--- a/crates/fiber-lib/src/rpc/README.md
+++ b/crates/fiber-lib/src/rpc/README.md
@@ -547,6 +547,7 @@ Generates a new invoice.
 * `udt_type_script` - <em>`Option<Script>`</em>, The UDT type script of the invoice.
 * `hash_algorithm` - <em>Option<[HashAlgorithm](#type-hashalgorithm)></em>, The hash algorithm of the invoice.
 * `allow_mpp` - <em>`Option<bool>`</em>, Whether allow payment to use MPP
+* `allow_atomic_mpp` - <em>`Option<bool>`</em>, Whether use atomic mpp, if use atomic mpp there will be no preimage generated.
 
 ##### Returns
 
@@ -658,6 +659,9 @@ Sends a payment to a peer.
 * `max_fee_amount` - <em>`Option<u128>`</em>, the maximum fee amounts in shannons that the sender is willing to pay
 * `max_parts` - <em>`Option<u64>`</em>, max parts for the payment, only used for multi-part payments
 * `keysend` - <em>`Option<bool>`</em>, keysend payment
+* `amp` - <em>`Option<bool>`</em>, whether to use AMP for the payment, default is false
+ Note: this is also required if the invoice is AMP invoice
+       this option is exclusive with `keysend` option, and `payment_hash` must be None
 * `udt_type_script` - <em>`Option<Script>`</em>, udt type script for the payment
 * `allow_self_payment` - <em>`Option<bool>`</em>, allow self payment, default is false
 * `custom_records` - <em>Option<[PaymentCustomRecords](#type-paymentcustomrecords)></em>, Some custom records for the payment which contains a map of u32 to Vec<u8>
@@ -792,6 +796,9 @@ Sends a payment to a peer with specified router
   }
  ```
 * `keysend` - <em>`Option<bool>`</em>, keysend payment
+* `amp` - <em>`Option<bool>`</em>, whether to use AMP for the payment, default is false
+ Note: this is also required if the invoice is AMP invoice
+       this option is exclusive with `keysend` option, and `payment_hash` must be None
 * `udt_type_script` - <em>`Option<Script>`</em>, udt type script for the payment
 * `dry_run` - <em>`Option<bool>`</em>, dry_run for payment, used for check whether we can build valid router and the fee for this payment,
  it's useful for the sender to double check the payment before sending it to the network,
@@ -1054,6 +1061,7 @@ The attributes of the invoice
 * `HashAlgorithm` - <em>[HashAlgorithm](#type-hashalgorithm)</em>, The hash algorithm of the invoice
 * `Feature` - <em>`Vec<String>`</em>, The feature flags of the invoice
 * `PaymentSecret` - <em>[Hash256](#type-hash256)</em>, The payment secret of the invoice
+* `Reuse` - <em>`bool`</em>, Reuse
 ---
 
 <a id="#type-cchinvoice"></a>
diff --git a/crates/fiber-lib/src/rpc/graph.rs b/crates/fiber-lib/src/rpc/graph.rs
index b0f62bf60..74a43f1dd 100644
--- a/crates/fiber-lib/src/rpc/graph.rs
+++ b/crates/fiber-lib/src/rpc/graph.rs
@@ -241,7 +241,7 @@ impl From<super::super::fiber::graph::ChannelInfo> for ChannelInfo {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct GraphChannelsResult {
     /// A list of channels.
     pub channels: Vec<ChannelInfo>,
diff --git a/crates/fiber-lib/src/rpc/invoice.rs b/crates/fiber-lib/src/rpc/invoice.rs
index 4501996d0..3f4a9625a 100644
--- a/crates/fiber-lib/src/rpc/invoice.rs
+++ b/crates/fiber-lib/src/rpc/invoice.rs
@@ -55,6 +55,8 @@ pub enum Attribute {
     Feature(Vec<String>),
     /// The payment secret of the invoice
     PaymentSecret(Hash256),
+    /// Reuse
+    Reuse(bool),
 }
 
 /// The metadata of the invoice
@@ -162,6 +164,8 @@ pub struct NewInvoiceParams {
     pub hash_algorithm: Option<HashAlgorithm>,
     /// Whether allow payment to use MPP
     pub allow_mpp: Option<bool>,
+    /// Whether use atomic mpp, if use atomic mpp there will be no preimage generated.
+    pub allow_atomic_mpp: Option<bool>,
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug)]
@@ -374,47 +378,64 @@ where
                 ));
             }
         }
+
         let mut invoice_builder = InvoiceBuilder::new(params.currency).amount(Some(params.amount));
 
+        let basic_mpp = params.allow_mpp.unwrap_or_default();
+        let atomic_mpp = params.allow_atomic_mpp.unwrap_or_default();
+        let payment_hash = params
+            .payment_hash
+            .or_else(|| atomic_mpp.then(gen_rand_sha256_hash));
+        let need_gen_preimage = payment_hash.is_none();
+
         // If both preimage and hash are absent, a random preimage is generated.
-        let preimage_opt = match (params.payment_preimage, params.payment_hash) {
-            (Some(preimage), _) => Some(preimage),
-            (None, None) => Some(gen_rand_sha256_hash()),
-            _ => None,
-        };
+        let preimage_opt = params
+            .payment_preimage
+            .or_else(|| need_gen_preimage.then(gen_rand_sha256_hash));
 
         if let Some(preimage) = preimage_opt {
             invoice_builder = invoice_builder.payment_preimage(preimage);
         }
-        if let Some(hash) = params.payment_hash {
+        if let Some(hash) = payment_hash {
             invoice_builder = invoice_builder.payment_hash(hash);
         }
+
         if let Some(description) = params.description.clone() {
             invoice_builder = invoice_builder.description(description);
         };
         if let Some(expiry) = params.expiry {
-            let duration: Duration = Duration::from_secs(expiry);
-            invoice_builder = invoice_builder.expiry_time(duration);
+            invoice_builder = invoice_builder.expiry_time(Duration::from_secs(expiry));
         };
         if let Some(fallback_address) = params.fallback_address.clone() {
             invoice_builder = invoice_builder.fallback_address(fallback_address);
         };
 
-        if let Some(allow_mpp) = params.allow_mpp {
-            invoice_builder = invoice_builder.allow_mpp(allow_mpp);
-            if allow_mpp {
-                if !self
-                    .node_features
-                    .as_ref()
-                    .is_some_and(|f| f.supports_basic_mpp())
-                {
-                    return error("Node does not support MPP, please enable MPP feature");
-                }
-                let mut rng = rand::thread_rng();
-                let payment_secret: [u8; 32] = rng.gen();
-                invoice_builder = invoice_builder.payment_secret(payment_secret.into());
+        if basic_mpp {
+            if !self
+                .node_features
+                .as_ref()
+                .is_some_and(|f| f.supports_basic_mpp())
+            {
+                return error("Node does not support MPP, please enable MPP feature");
             }
+            invoice_builder = invoice_builder.allow_basic_mpp(true);
+
+            let mut rng = rand::thread_rng();
+            let payment_secret: [u8; 32] = rng.gen();
+            invoice_builder = invoice_builder.payment_secret(payment_secret.into());
         };
+
+        if atomic_mpp {
+            if !self
+                .node_features
+                .as_ref()
+                .is_some_and(|f| f.supports_atomic_mpp())
+            {
+                return error("Node does not support Atomic MPP, please enable Atomic MPP feature");
+            }
+            invoice_builder = invoice_builder.allow_atomic_mpp(true);
+        }
+
         if let Some(final_expiry_delta) = params.final_expiry_delta {
             if final_expiry_delta < MIN_TLC_EXPIRY_DELTA {
                 return error(&format!(
diff --git a/crates/fiber-lib/src/rpc/payment.rs b/crates/fiber-lib/src/rpc/payment.rs
index beecef490..e358d3bfe 100644
--- a/crates/fiber-lib/src/rpc/payment.rs
+++ b/crates/fiber-lib/src/rpc/payment.rs
@@ -139,6 +139,11 @@ pub struct SendPaymentCommandParams {
     /// keysend payment
     pub keysend: Option<bool>,
 
+    /// whether to use AMP for the payment, default is false
+    /// Note: this is also required if the invoice is AMP invoice
+    ///       this option is exclusive with `keysend` option, and `payment_hash` must be None
+    pub amp: Option<bool>,
+
     /// udt type script for the payment
     pub udt_type_script: Option<Script>,
 
@@ -175,6 +180,7 @@ pub struct SendPaymentCommandParams {
     /// default is false
     pub dry_run: Option<bool>,
 }
+
 /// A hop hint is a hint for a node to use a specific channel.
 #[serde_as]
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -270,6 +276,11 @@ pub struct SendPaymentWithRouterParams {
     /// keysend payment
     pub keysend: Option<bool>,
 
+    /// whether to use AMP for the payment, default is false
+    /// Note: this is also required if the invoice is AMP invoice
+    ///       this option is exclusive with `keysend` option, and `payment_hash` must be None
+    pub amp: Option<bool>,
+
     /// udt type script for the payment
     pub udt_type_script: Option<Script>,
 
@@ -386,6 +397,7 @@ where
                     max_fee_amount: params.max_fee_amount,
                     max_parts: params.max_parts,
                     keysend: params.keysend,
+                    atomic_mpp: params.amp,
                     udt_type_script: params.udt_type_script.clone().map(|s| s.into()),
                     allow_self_payment: params.allow_self_payment.unwrap_or(false),
                     custom_records: params.custom_records.clone().map(|records| records.into()),
diff --git a/crates/fiber-lib/src/store/.schema.json b/crates/fiber-lib/src/store/.schema.json
index b4d047d6a..bcd901695 100644
--- a/crates/fiber-lib/src/store/.schema.json
+++ b/crates/fiber-lib/src/store/.schema.json
@@ -1,7 +1,10 @@
 {
   "AddTlcCommand": "31129451de66547e68f560c9b40fcc25d8e5a73de9b1aaebd8b09bf42d49467f",
+  "AmpChildDesc": "44986778840b6038f2535b7b79cd72981af1c8cca4d768cb48a3310662fff481",
+  "AmpPaymentData": "627095c67822aa6d7a1195fd0abdff8e920164e4847a6b34d4b2600b077abcd6",
+  "AmpSecret": "a17107d5b43b69f1a75985fcee5eea56751e3b30a37f2e343e69885642800481",
   "AnnouncedNodeName": "73035cf37b0bbc724336af8a5982ca40a37d6fdcb6f7b0fed98158b4afb51260",
-  "Attempt": "fc9bca945949fd6ac5591daf8ea2f2ca253698231801c3f6cf03cc01e7f7a94a",
+  "Attempt": "81aa827fa414d50908f82bfa259019fa863b045f13de069e0b83d20fe7dd27f8",
   "AttemptStatus": "b18d88f1743ca9a7b657daa273e3ec3cab475113c2b34704792f8ca7a382313a",
   "Attribute": "bee9e44e53d7428c6881544b3859b5074d3ec016f45ba027fba7b92d1c9c2d4b",
   "BroadcastMessage": "c15fb7747e489e3ace898276a811a61060f3913bf8d6143ed9ab895d97128469",
@@ -50,7 +53,7 @@
   "RevocationData": "c0f5d8ad460e41ae741c50ea07a2641569a3941f711cad44c52a5aa5628ac48d",
   "RevokeAndAck": "7c2baa88ab2bc21276132deb03d51f61fad24f256678eb538da8139294719394",
   "RouterHop": "10cc5df6c304bc3b2242add0b6a6f297015a09fd7f453667bdf65a5e4e872cd3",
-  "SendPaymentData": "43b38b50aa4c26407a7b92fa89932acb9365e0420048512dec7f34e48c55b4fc",
+  "SendPaymentData": "5bcc6938037f5ebf721bc1afc3b52fdb721c842036fdef6146bc7b313f702c3a",
   "SessionRoute": "17ca3487423c528df34fd906b573af20fa2cd3f35c8ecaa9ca8f3138a7b7541f",
   "SessionRouteNode": "3905d18b71ffcaac5abf78441b70b445bf406dd6582aeaa7db354049c05f4395",
   "SettlementData": "d0ba7433dccf965ee9d9dd2b953179c040e5cc9fd7eff9b7d3da1d69862548d9",
@@ -59,7 +62,7 @@
   "TLCId": "24cfc1ee6e30324799650836244b4373bb78aaf80b1151c37252a748a468f73d",
   "TimedResult": "7c79614a5e8c62920bfb3b367747ff014877893c70e55f364bc8e63a1c4f1491",
   "TlcErrPacket": "9beaab8b903ec6d396f922659aafe30f2d140c40cef6eb1b85c67063856ba3b5",
-  "TlcInfo": "dd90e2ccc84e039c57bfccd0a7e3f78c2e18a7f408c03253733303d3a2788188",
+  "TlcInfo": "60813fdeb27a6b859bf6e25f2af602bff70be3152a51916267cbb08b20895f98",
   "TlcState": "e76d434a42bc9ee31dcfa22b3c67d41eaa105fefc86a397bcd21f0e94c53765d",
   "TlcStatus": "c6e573785811e5289908255ec8e30c55af5aa9bb6c8b97a90d3d0abace00b983",
   "UdtCfgInfos": "810d91ca44e779cfebb4ab1dffb1072c7993bdf9af22423abed2e339586d09fa"
diff --git a/crates/fiber-lib/src/store/schema.rs b/crates/fiber-lib/src/store/schema.rs
index 0506671cf..b9bee985b 100644
--- a/crates/fiber-lib/src/store/schema.rs
+++ b/crates/fiber-lib/src/store/schema.rs
@@ -30,7 +30,9 @@ pub(crate) const PAYMENT_SESSION_PREFIX: u8 = 192;
 pub(crate) const PAYMENT_HISTORY_TIMED_RESULT_PREFIX: u8 = 193;
 pub(crate) const PAYMENT_CUSTOM_RECORD_PREFIX: u8 = 194;
 pub(crate) const ATTEMPT_PREFIX: u8 = 195;
+pub(crate) const ATTEMPT_HASH_PREFIX: u8 = 196;
 pub(crate) const HOLD_TLC_PREFIX: u8 = 197;
+pub(crate) const HOLD_TLC_ATOMIC_PAYMENT_DATA_PREFIX: u8 = 198;
 #[cfg(feature = "watchtower")]
 mod watchtower {
     pub(crate) const WATCHTOWER_CHANNEL_PREFIX: u8 = 224;
diff --git a/crates/fiber-lib/src/store/store_impl/mod.rs b/crates/fiber-lib/src/store/store_impl/mod.rs
index 6766eafd7..a79e48f0e 100644
--- a/crates/fiber-lib/src/store/store_impl/mod.rs
+++ b/crates/fiber-lib/src/store/store_impl/mod.rs
@@ -19,6 +19,7 @@ use std::path::Path;
 
 use super::db_migrate::DbMigrate;
 use super::schema::*;
+use crate::fiber::builtin_records::AmpPaymentData;
 use crate::fiber::gossip::GossipMessageStore;
 use crate::fiber::payment::{Attempt, AttemptStatus, PaymentSession, PaymentStatus};
 use crate::fiber::types::{HoldTlc, CURSOR_SIZE};
@@ -201,14 +202,13 @@ impl Store {
             .expect("channel_id should be 32 bytes");
 
         let tlc_id: u64 =
-            u64::from_le_bytes(key[65..].try_into().expect("tlc_id should be 8 bytes"));
-
-        let expired_at: u64 = deserialize_from(value, "HoldTlc");
+            u64::from_le_bytes(key[65..73].try_into().expect("tlc_id should be 8 bytes"));
 
+        let hold_expire_at: u64 = deserialize_from(value, "HoldTlc");
         let hold_tlc = HoldTlc {
             channel_id: channel_id.into(),
             tlc_id,
-            hold_expire_at: expired_at,
+            hold_expire_at,
         };
 
         (payment_hash.into(), hold_tlc)
@@ -237,7 +237,9 @@ pub enum KeyValue {
     PaymentCustomRecord(Hash256, PaymentCustomRecords),
     NetworkActorState(PeerId, PersistentNetworkActorState),
     Attempt((Hash256, u64), Attempt),
+    AttemptToPaymentHash((Hash256, u64), Hash256),
     HoldTlc((Hash256, Hash256, u64), u64),
+    HoldTlcAtomicPaymentData((Hash256, Hash256, u64), AmpPaymentData),
 }
 
 /// Recorded store changes.
@@ -301,6 +303,12 @@ impl StoreKeyValue for KeyValue {
                 &attempt_id.to_le_bytes(),
             ]
             .concat(),
+            KeyValue::AttemptToPaymentHash((attempt_hash, attempt_id), _) => [
+                &[ATTEMPT_HASH_PREFIX],
+                attempt_hash.as_ref(),
+                &attempt_id.to_le_bytes(),
+            ]
+            .concat(),
             #[cfg(feature = "watchtower")]
             KeyValue::WatchtowerChannel(node_id, channel_id, _) => [
                 &[WATCHTOWER_CHANNEL_PREFIX],
@@ -343,13 +351,20 @@ impl StoreKeyValue for KeyValue {
             KeyValue::PaymentCustomRecord(payment_hash, _data) => {
                 [&[PAYMENT_CUSTOM_RECORD_PREFIX], payment_hash.as_ref()].concat()
             }
-            KeyValue::HoldTlc((payment_hash, channel_id, tlc_id), _hold_tlc) => [
+            KeyValue::HoldTlc((payment_hash, channel_id, tlc_id), _expired_at) => [
                 &[HOLD_TLC_PREFIX],
                 payment_hash.as_ref(),
                 channel_id.as_ref(),
                 &tlc_id.to_le_bytes(),
             ]
             .concat(),
+            KeyValue::HoldTlcAtomicPaymentData((payment_hash, channel_id, tlc_id), _data) => [
+                &[HOLD_TLC_ATOMIC_PAYMENT_DATA_PREFIX],
+                payment_hash.as_ref(),
+                channel_id.as_ref(),
+                &tlc_id.to_le_bytes(),
+            ]
+            .concat(),
         }
     }
 
@@ -365,6 +380,9 @@ impl StoreKeyValue for KeyValue {
                 serialize_to_vec(payment_session, "PaymentSession")
             }
             KeyValue::Attempt(_, attempt) => serialize_to_vec(attempt, "Attempt"),
+            KeyValue::AttemptToPaymentHash(_, payment_hash) => {
+                serialize_to_vec(payment_hash, "Hash256")
+            }
             #[cfg(feature = "watchtower")]
             KeyValue::WatchtowerChannel(_, _, channel_data) => {
                 serialize_to_vec(channel_data, "ChannelData")
@@ -387,7 +405,8 @@ impl StoreKeyValue for KeyValue {
             KeyValue::PaymentCustomRecord(_, custom_records) => {
                 serialize_to_vec(custom_records, "PaymentCustomRecord")
             }
-            KeyValue::HoldTlc(_, expired_at) => serialize_to_vec(expired_at, "HoldTlc"),
+            KeyValue::HoldTlc(_, expired_at) => serialize_to_vec(&expired_at, "HoldTlc"),
+            KeyValue::HoldTlcAtomicPaymentData(_, data) => serialize_to_vec(data, "AMPPaymentData"),
         }
     }
 }
@@ -519,6 +538,16 @@ impl ChannelActorStateStore for Store {
         .concat();
         let mut batch = self.batch();
         batch.delete(prefix);
+
+        // remove atomic mpp payment_data
+        let prefix = [
+            &[HOLD_TLC_ATOMIC_PAYMENT_DATA_PREFIX],
+            payment_hash.as_ref(),
+            channel_id.as_ref(),
+            &tlc_id.to_le_bytes(),
+        ]
+        .concat();
+        batch.delete(prefix);
         batch.commit();
     }
 
@@ -541,6 +570,44 @@ impl ChannelActorStateStore for Store {
                 acc
             })
     }
+
+    fn insert_atomic_mpp_payment_data(
+        &self,
+        payment_hash: Hash256,
+        channel_id: Hash256,
+        tlc_id: u64,
+        payment_data: AmpPaymentData,
+    ) {
+        let mut batch = self.batch();
+        batch.put_kv(KeyValue::HoldTlcAtomicPaymentData(
+            (payment_hash, channel_id, tlc_id),
+            payment_data,
+        ));
+        batch.commit();
+    }
+
+    fn get_atomic_mpp_payment_data(
+        &self,
+        payment_hash: &Hash256,
+    ) -> Vec<((Hash256, u64), AmpPaymentData)> {
+        let prefix = [
+            &[HOLD_TLC_ATOMIC_PAYMENT_DATA_PREFIX],
+            payment_hash.as_ref(),
+        ]
+        .concat();
+        self.prefix_iterator(&prefix)
+            .map(|(key, value)| {
+                let channel_id: [u8; 32] = key[33..65]
+                    .try_into()
+                    .expect("channel_id should be 32 bytes");
+                let tlc_id: u64 =
+                    u64::from_le_bytes(key[65..73].try_into().expect("tlc_id should be 8 bytes"));
+                let payment_data: AmpPaymentData =
+                    deserialize_from(value.as_ref(), "AMPPaymentData");
+                ((channel_id.into(), tlc_id), payment_data)
+            })
+            .collect()
+    }
 }
 
 impl InvoiceStore for Store {
@@ -668,6 +735,10 @@ impl NetworkGraphStateStore for Store {
     fn insert_attempt(&self, attempt: Attempt) {
         assert_ne!(attempt.id, 0, "Attempt ID should not be zero");
         let mut batch = self.batch();
+        batch.put_kv(KeyValue::AttemptToPaymentHash(
+            (attempt.hash, attempt.id),
+            attempt.payment_hash,
+        ));
         batch.put_kv(KeyValue::Attempt(
             (attempt.payment_hash, attempt.id),
             attempt,
@@ -682,12 +753,36 @@ impl NetworkGraphStateStore for Store {
             .collect()
     }
 
+    fn get_payment_hash_with_attempt_hash(
+        &self,
+        attempt_hash: Hash256,
+        attempt_id: u64,
+    ) -> Option<Hash256> {
+        let key = [
+            &[ATTEMPT_HASH_PREFIX],
+            attempt_hash.as_ref(),
+            &attempt_id.to_le_bytes(),
+        ]
+        .concat();
+        self.get(key)
+            .map(|v| deserialize_from(v.as_ref(), "Hash256"))
+    }
+
     fn delete_attempts(&self, payment_hash: Hash256) {
         let prefix = [&[ATTEMPT_PREFIX], payment_hash.as_ref()].concat();
         let mut batch = self.batch();
-        for (key, _) in self.prefix_iterator(&prefix) {
+        let mut attempt_to_payments = vec![];
+        for (key, value) in self.prefix_iterator(&prefix) {
+            let attempt: Attempt = deserialize_from(value.as_ref(), "Attempt");
+            attempt_to_payments.push(KeyValue::AttemptToPaymentHash(
+                (attempt.hash, attempt.id),
+                attempt.payment_hash,
+            ));
             batch.delete(key);
         }
+        for attempt_hash in attempt_to_payments {
+            batch.delete(attempt_hash.key());
+        }
         batch.commit();
     }
 
diff --git a/crates/fiber-lib/src/store/tests/store.rs b/crates/fiber-lib/src/store/tests/store.rs
index fbe386ca5..516b7c42b 100644
--- a/crates/fiber-lib/src/store/tests/store.rs
+++ b/crates/fiber-lib/src/store/tests/store.rs
@@ -713,7 +713,8 @@ fn test_store_payment_session() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let payment_session = PaymentSession::new(&store, payment_data.clone(), 10);
@@ -747,7 +748,8 @@ fn test_store_payment_sessions_with_status() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let payment_session = PaymentSession::new(&store, payment_data.clone(), 10);
@@ -772,7 +774,8 @@ fn test_store_payment_sessions_with_status() {
         dry_run: false,
         custom_records: None,
         router: vec![],
-        allow_mpp: false,
+        allow_basic_mpp: false,
+        allow_atomic_mpp: false,
         channel_stats: Default::default(),
     };
     let mut payment_session = PaymentSession::new(&store, payment_data.clone(), 10);
diff --git a/crates/fiber-lib/src/tests/test_utils.rs b/crates/fiber-lib/src/tests/test_utils.rs
index 6b346717e..17ac466b1 100644
--- a/crates/fiber-lib/src/tests/test_utils.rs
+++ b/crates/fiber-lib/src/tests/test_utils.rs
@@ -10,6 +10,7 @@ use crate::fiber::gossip::GossipActorMessage;
 use crate::fiber::graph::NetworkGraphStateStore;
 use crate::fiber::network::*;
 use crate::fiber::payment::Attempt;
+use crate::fiber::payment::MppMode;
 use crate::fiber::payment::PaymentSession;
 use crate::fiber::payment::PaymentStatus;
 use crate::fiber::payment::SessionRoute;
@@ -749,6 +750,27 @@ impl NetworkNode {
                 dry_run: false,
                 ..Default::default()
             },
+            MppMode::BasicMpp,
+        )
+        .await
+    }
+
+    pub async fn send_atomic_mpp_payment(
+        &self,
+        target_node: &NetworkNode,
+        amount: u128,
+        max_parts: Option<u64>,
+    ) -> Result<SendPaymentResponse, String> {
+        self.send_mpp_payment_with_command(
+            target_node,
+            amount,
+            SendPaymentCommand {
+                max_parts,
+                dry_run: false,
+                atomic_mpp: Some(true),
+                ..Default::default()
+            },
+            MppMode::AtomicMpp,
         )
         .await
     }
@@ -759,6 +781,7 @@ impl NetworkNode {
         amount: u128,
         max_parts: Option<u64>,
         dry_run: bool,
+        mode: MppMode,
     ) -> Result<SendPaymentResponse, String> {
         self.send_mpp_payment_with_command(
             target_node,
@@ -768,6 +791,7 @@ impl NetworkNode {
                 dry_run,
                 ..Default::default()
             },
+            mode,
         )
         .await
     }
@@ -777,21 +801,40 @@ impl NetworkNode {
         target_node: &NetworkNode,
         amount: u128,
         command: SendPaymentCommand,
+        mode: MppMode,
     ) -> Result<SendPaymentResponse, String> {
         let target_pubkey = target_node.get_public_key();
-        let preimage = gen_rand_sha256_hash();
-        let ckb_invoice = InvoiceBuilder::new(Currency::Fibd)
+
+        let mut builder = InvoiceBuilder::new(Currency::Fibd)
             .amount(Some(amount))
-            .payment_preimage(preimage)
-            .payee_pub_key(target_pubkey.into())
-            .allow_mpp(true)
-            .payment_secret(gen_rand_sha256_hash())
-            .build()
-            .expect("build invoice success");
-
-        target_node.insert_invoice(ckb_invoice.clone(), Some(preimage));
+            .payee_pub_key(target_pubkey.into());
+        let preimage = match mode {
+            MppMode::BasicMpp => {
+                let preimage = gen_rand_sha256_hash();
+                builder = builder
+                    .allow_basic_mpp(true)
+                    .payment_preimage(preimage)
+                    .payment_secret(gen_rand_sha256_hash());
+                Some(preimage)
+            }
+
+            MppMode::AtomicMpp => {
+                // use a random hash for atomic mpp
+                builder = builder
+                    .allow_atomic_mpp(true)
+                    .payment_hash(gen_rand_sha256_hash());
+                None
+            }
+        };
+        let ckb_invoice = builder.build().expect("build invoice success");
+        target_node.insert_invoice(ckb_invoice.clone(), preimage);
         let mut command = command.clone();
         command.invoice = Some(ckb_invoice.to_string());
+        let atomic_mpp = match mode {
+            MppMode::BasicMpp => None,
+            MppMode::AtomicMpp => Some(true),
+        };
+        command.atomic_mpp = atomic_mpp;
 
         self.send_payment(command).await
     }
@@ -931,6 +974,7 @@ impl NetworkNode {
         params: P,
     ) -> Result<R, String> {
         let response = self.send_rpc_request_raw(method, params).await?;
+        debug!("test rpc response: {}", response);
         let result = serde_json::from_value::<R>(response.clone())
             .map_err(|e| format!("failed to deserialize response: {}", e))?;
         Ok(result)
diff --git a/crates/fiber-lib/src/utils/payment.rs b/crates/fiber-lib/src/utils/payment.rs
index 52203752f..9e9f955ec 100644
--- a/crates/fiber-lib/src/utils/payment.rs
+++ b/crates/fiber-lib/src/utils/payment.rs
@@ -1,4 +1,7 @@
-use crate::{fiber::channel::TlcInfo, invoice::CkbInvoice};
+use crate::{
+    fiber::{channel::TlcInfo, payment::MppMode},
+    invoice::CkbInvoice,
+};
 use tracing::debug;
 
 /// Check if the invoice is fulfilled by the tlc set
@@ -17,6 +20,10 @@ pub fn is_invoice_fulfilled(invoice: &CkbInvoice, tlc_set: &[TlcInfo]) -> bool {
         return false;
     };
 
+    if invoice.mpp_mode() == Some(MppMode::AtomicMpp) {
+        return is_atomic_mpp_fulfilled(tlc_set);
+    }
+
     // check if total_amount is enough
     let total_amount = first_tlc.total_amount.unwrap_or(first_tlc.amount);
 
@@ -32,3 +39,17 @@ pub fn is_invoice_fulfilled(invoice: &CkbInvoice, tlc_set: &[TlcInfo]) -> bool {
     );
     total_tlc_amount >= total_amount
 }
+
+pub fn is_atomic_mpp_fulfilled(tlc_set: &[TlcInfo]) -> bool {
+    if tlc_set.is_empty() {
+        return false;
+    }
+    let first_tlc = &tlc_set[0];
+    let total_amount = first_tlc.total_amount.unwrap_or(first_tlc.amount);
+    let total_tlc_amount = tlc_set.iter().map(|tlc| tlc.amount).sum::<u128>();
+    debug!(
+        "checking atomic mpp total_tlc_amount: {}, total_amount: {}",
+        total_tlc_amount, total_amount
+    );
+    total_tlc_amount >= total_amount
+}