feat(networking): add TransactionWithPayment

ant-networking/src/cmd.rs

@@ -668,6 +668,7 @@ impl SwarmDriver {
                             }
                             RecordKind::ChunkWithPayment
                             | RecordKind::RegisterWithPayment
+                            | RecordKind::TransactionWithPayment
                             | RecordKind::ScratchpadWithPayment => {
                                 error!("Record {record_key:?} with payment shall not be stored locally.");
                                 return Err(NetworkError::InCorrectRecordHeader);

ant-networking/src/lib.rs

@@ -638,6 +638,7 @@ impl Network {
                 match kind {
                     RecordKind::Chunk
                     | RecordKind::ChunkWithPayment
+                    | RecordKind::TransactionWithPayment
                     | RecordKind::RegisterWithPayment
                     | RecordKind::ScratchpadWithPayment => {
                         error!("Encountered a split record for {pretty_key:?} with unexpected RecordKind {kind:?}, skipping.");

ant-node/src/put_validation.rs

@@ -186,6 +186,55 @@ impl Node {
                 }
                 result
             }
+            RecordKind::TransactionWithPayment => {
+                let (payment, transaction) =
+                    try_deserialize_record::<(ProofOfPayment, Transaction)>(&record)?;
+
+                // check if the deserialized value's TransactionAddress matches the record's key
+                let net_addr = NetworkAddress::from_transaction_address(transaction.address());
+                let key = net_addr.to_record_key();
+                let pretty_key = PrettyPrintRecordKey::from(&key);
+                if record.key != key {
+                    warn!(
+                        "Record's key {pretty_key:?} does not match with the value's TransactionAddress, ignoring PUT."
+                    );
+                    return Err(Error::RecordKeyMismatch);
+                }
+
+                let already_exists = self.validate_key_and_existence(&net_addr, &key).await?;
+
+                // The transaction may already exist during the replication.
+                // The payment shall get deposit to self even the transaction already presents.
+                // However, if the transaction already presents, the incoming one maybe for edit only.
+                // Hence the corresponding payment error shall not be thrown out.
+                if let Err(err) = self
+                    .payment_for_us_exists_and_is_still_valid(&net_addr, payment)
+                    .await
+                {
+                    if already_exists {
+                        debug!("Payment of the incoming exists transaction {pretty_key:?} having error {err:?}");
+                    } else {
+                        error!("Payment of the incoming non-exist transaction {pretty_key:?} having error {err:?}");
+                        return Err(err);
+                    }
+                }
+
+                let res = self
+                    .validate_merge_and_store_transactions(vec![transaction], &key)
+                    .await;
+                if res.is_ok() {
+                    let content_hash = XorName::from_content(&record.value);
+
+                    // Notify replication_fetcher to mark the attempt as completed.
+                    // Send the notification earlier to avoid it got skipped due to:
+                    // the record becomes stored during the fetch because of other interleaved process.
+                    self.network().notify_fetch_completed(
+                        record.key.clone(),
+                        RecordType::NonChunk(content_hash),
+                    );
+                }
+                res
+            }
             RecordKind::Register => {
                 let register = try_deserialize_record::<SignedRegister>(&record)?;
 
@@ -282,6 +331,7 @@ impl Node {
         match record_header.kind {
             // A separate flow handles payment for chunks and registers
             RecordKind::ChunkWithPayment
+            | RecordKind::TransactionWithPayment
             | RecordKind::RegisterWithPayment
             | RecordKind::ScratchpadWithPayment => {
                 warn!("Prepaid record came with Payment, which should be handled in another flow");

ant-protocol/src/storage/header.rs

@@ -35,6 +35,7 @@ pub enum RecordKind {
     Chunk,
     ChunkWithPayment,
     Transaction,
+    TransactionWithPayment,
     Register,
     RegisterWithPayment,
     Scratchpad,
@@ -54,6 +55,7 @@ impl Serialize for RecordKind {
             Self::RegisterWithPayment => serializer.serialize_u32(4),
             Self::Scratchpad => serializer.serialize_u32(5),
             Self::ScratchpadWithPayment => serializer.serialize_u32(6),
+            Self::TransactionWithPayment => serializer.serialize_u32(7),
         }
     }
 }
@@ -72,6 +74,7 @@ impl<'de> Deserialize<'de> for RecordKind {
             4 => Ok(Self::RegisterWithPayment),
             5 => Ok(Self::Scratchpad),
             6 => Ok(Self::ScratchpadWithPayment),
+            7 => Ok(Self::TransactionWithPayment),
             _ => Err(serde::de::Error::custom(
                 "Unexpected integer for RecordKind variant",
             )),