R21 bc 245

include/xpxchaincpp/model/transaction/data_modification_cancel_transaction.h

@@ -26,7 +26,7 @@ namespace xpx_chain_sdk {
 				const Key& driveKey,
 				const Hash256& dataModificationId,
 		        TArgs&&... args):
-			TBase(TransactionType::Data_Modification_Approval, std::forward<TArgs>(args)...),
+			TBase(TransactionType::Data_Modification_Cancel, std::forward<TArgs>(args)...),
 			driveKey_(driveKey),
 			dataModificationId_(dataModificationId)
 		{ }

include/xpxchaincpp/model/transaction/download_payment_transaction.h

@@ -0,0 +1,78 @@
+/**
+*** Copyright 2021 ProximaX Limited. All rights reserved.
+*** Use of this source code is governed by the Apache 2.0
+*** license that can be found in the LICENSE file.
+**/
+#pragma once
+
+#include <xpxchaincpp/utils/buffer.h>
+#include <xpxchaincpp/model/transaction/transaction.h>
+#include <xpxchaincpp/model/transaction/embedded_transaction.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace xpx_chain_sdk {
+
+	/// Download payment transaction base class.
+	template<typename TBase>
+	class TDownloadPaymentTransaction: public TBase {
+	public:
+		/// Creates download payment transaction.
+		template<typename... TArgs>
+		explicit TDownloadPaymentTransaction(
+				const Hash256& downloadChannelId,
+				uint64_t downloadSize,
+				const Amount& feedbackFeeAmount,
+		        TArgs&&... args):
+			TBase(TransactionType::Download_Payment, std::forward<TArgs>(args)...),
+            downloadChannelId_(downloadChannelId),
+			downloadSize_(downloadSize),
+            feedbackFeeAmount_(feedbackFeeAmount)
+		{ }
+
+		/// Returns identifier of the download channel.
+		const Hash256& downloadChannelId() const;
+
+		/// Returns download size to add to the prepaid size of the download channel.
+		uint64_t downloadSize() const;
+
+		/// Returns amount of XPXs to transfer to the download channel.
+		const Amount& feedbackFeeAmount() const;
+
+	private:
+        Hash256 downloadChannelId_;
+		uint64_t downloadSize_;
+        Amount feedbackFeeAmount_;
+	};
+
+	extern template class TDownloadPaymentTransaction<Transaction>;
+	extern template class TDownloadPaymentTransaction<EmbeddedTransaction>;
+
+	using DownloadPaymentTransaction = TDownloadPaymentTransaction<Transaction>;
+	using EmbeddedDownloadPaymentTransaction = TDownloadPaymentTransaction<EmbeddedTransaction>;
+
+	/// Creates download payment transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+	std::unique_ptr<DownloadPaymentTransaction>
+    CreateDownloadPaymentTransaction(const Hash256& downloadChannelId,
+                                     uint64_t downloadSize,
+                                     const Amount& feedbackFeeAmount,
+                                     std::optional<Amount> maxFee = std::nullopt,
+                                     std::optional<NetworkDuration> deadline = std::nullopt,
+                                     std::optional<NetworkIdentifier> networkId = std::nullopt);
+
+
+	/// Creates download payment transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+    std::unique_ptr<EmbeddedDownloadPaymentTransaction>
+    CreateEmbeddedDownloadPaymentTransaction(const Hash256& downloadChannelId,
+                                             uint64_t downloadSize,
+                                             const Amount& feedbackFeeAmount,
+                                             const Key& signer,
+                                             std::optional<NetworkIdentifier> networkId = std::nullopt);
+}

include/xpxchaincpp/model/transaction/download_transaction.h

@@ -27,7 +27,7 @@ namespace xpx_chain_sdk {
 				uint64_t downloadSize,
 				const Amount& transactionFee,
 		        TArgs&&... args):
-			TBase(TransactionType::Data_Modification, std::forward<TArgs>(args)...),
+			TBase(TransactionType::Download, std::forward<TArgs>(args)...),
 			driveKey_(driveKey),
 			downloadSize_(downloadSize),
 			transactionFee_(transactionFee)

include/xpxchaincpp/model/transaction/drive_closure_transaction.h

@@ -0,0 +1,62 @@
+/**
+*** Copyright 2021 ProximaX Limited. All rights reserved.
+*** Use of this source code is governed by the Apache 2.0
+*** license that can be found in the LICENSE file.
+**/
+#pragma once
+
+#include <xpxchaincpp/utils/buffer.h>
+#include <xpxchaincpp/model/transaction/transaction.h>
+#include <xpxchaincpp/model/transaction/embedded_transaction.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace xpx_chain_sdk {
+
+	/// Drive closure transaction base class.
+	template<typename TBase>
+	class TDriveClosureTransaction: public TBase {
+	public:
+		/// Creates drive closure transaction.
+		template<typename... TArgs>
+		explicit TDriveClosureTransaction(
+				const Key& driveKey,
+		        TArgs&&... args):
+			TBase(TransactionType::Drive_Closure, std::forward<TArgs>(args)...),
+            driveKey_(driveKey)
+		{ }
+
+		/// Returns identifier of the drive.
+		const Hash256& driveKey() const;
+
+	private:
+        Key driveKey_;
+	};
+
+	extern template class TDriveClosureTransaction<Transaction>;
+	extern template class TDriveClosureTransaction<EmbeddedTransaction>;
+
+	using DriveClosureTransaction = TDriveClosureTransaction<Transaction>;
+	using EmbeddedDriveClosureTransaction = TDriveClosureTransaction<EmbeddedTransaction>;
+
+	/// Creates drive closure transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+	std::unique_ptr<DriveClosureTransaction>
+    CreateDriveClosureTransaction(const Key& driveKey,
+                                  std::optional<Amount> maxFee = std::nullopt,
+                                  std::optional<NetworkDuration> deadline = std::nullopt,
+                                  std::optional<NetworkIdentifier> networkId = std::nullopt);
+
+
+	/// Creates drive closure transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+    std::unique_ptr<EmbeddedDriveClosureTransaction>
+    CreateEmbeddedDriveClosureTransaction(const Key& driveKey,
+                                          const Key& signer,
+                                          std::optional<NetworkIdentifier> networkId = std::nullopt);
+}

include/xpxchaincpp/model/transaction/finish_download_transaction.h

@@ -0,0 +1,70 @@
+/**
+*** Copyright 2021 ProximaX Limited. All rights reserved.
+*** Use of this source code is governed by the Apache 2.0
+*** license that can be found in the LICENSE file.
+**/
+#pragma once
+
+#include <xpxchaincpp/utils/buffer.h>
+#include <xpxchaincpp/model/transaction/transaction.h>
+#include <xpxchaincpp/model/transaction/embedded_transaction.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace xpx_chain_sdk {
+
+	/// Finish download transaction base class.
+	template<typename TBase>
+	class TFinishDownloadTransaction: public TBase {
+	public:
+		/// Creates finish download transaction.
+		template<typename... TArgs>
+		explicit TFinishDownloadTransaction(
+				const Hash256& downloadChannelId,
+				const Amount& feedbackFeeAmount,
+		        TArgs&&... args):
+			TBase(TransactionType::Finish_Download, std::forward<TArgs>(args)...),
+            downloadChannelId_(downloadChannelId),
+            feedbackFeeAmount_(feedbackFeeAmount)
+		{ }
+
+		/// Returns identifier of the download channel.
+		const Hash256& downloadChannelId() const;
+
+		/// Returns amount of XPXs to transfer to the download channel.
+		const Amount& feedbackFeeAmount() const;
+
+	private:
+        Hash256 downloadChannelId_;
+        Amount feedbackFeeAmount_;
+	};
+
+	extern template class TFinishDownloadTransaction<Transaction>;
+	extern template class TFinishDownloadTransaction<EmbeddedTransaction>;
+
+	using FinishDownloadTransaction = TFinishDownloadTransaction<Transaction>;
+	using EmbeddedFinishDownloadTransaction = TFinishDownloadTransaction<EmbeddedTransaction>;
+
+	/// Creates finish download transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+	std::unique_ptr<FinishDownloadTransaction>
+    CreateFinishDownloadTransaction(const Hash256& downloadChannelId,
+                                    const Amount& feedbackFeeAmount,
+                                    std::optional<Amount> maxFee = std::nullopt,
+                                    std::optional<NetworkDuration> deadline = std::nullopt,
+                                    std::optional<NetworkIdentifier> networkId = std::nullopt);
+
+
+	/// Creates finish download transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+    std::unique_ptr<EmbeddedFinishDownloadTransaction>
+    CreateEmbeddedFinishDownloadTransaction(const Hash256& downloadChannelId,
+                                            const Amount& feedbackFeeAmount,
+                                            const Key& signer,
+                                            std::optional<NetworkIdentifier> networkId = std::nullopt);
+}

include/xpxchaincpp/model/transaction/replicator_onboarding_transaction.h

@@ -25,7 +25,7 @@ namespace xpx_chain_sdk {
 		explicit TReplicatorOnboardingTransaction(
 				const Amount& capacity,
 		        TArgs&&... args):
-			TBase(TransactionType::Data_Modification, std::forward<TArgs>(args)...),
+			TBase(TransactionType::Replicator_Onboarding, std::forward<TArgs>(args)...),
 			capacity_(capacity)
 		{ }
 

include/xpxchaincpp/model/transaction/storage_payment_transaction.h

@@ -0,0 +1,70 @@
+/**
+*** Copyright 2021 ProximaX Limited. All rights reserved.
+*** Use of this source code is governed by the Apache 2.0
+*** license that can be found in the LICENSE file.
+**/
+#pragma once
+
+#include <xpxchaincpp/utils/buffer.h>
+#include <xpxchaincpp/model/transaction/transaction.h>
+#include <xpxchaincpp/model/transaction/embedded_transaction.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+
+namespace xpx_chain_sdk {
+
+	/// Storage payment transaction base class.
+	template<typename TBase>
+	class TStoragePaymentTransaction: public TBase {
+	public:
+		/// Creates storage payment transaction.
+		template<typename... TArgs>
+		explicit TStoragePaymentTransaction(
+				const Key& driveKey,
+				const Amount& storageUnits,
+		        TArgs&&... args):
+			TBase(TransactionType::Storage_Payment, std::forward<TArgs>(args)...),
+            driveKey_(driveKey),
+            storageUnits_(storageUnits)
+		{ }
+
+		/// Returns identifier of the drive.
+		const Key& driveKey() const;
+
+		/// Returns amount of storage units to transfer to the drive.
+		const Amount& storageUnitsAmount() const;
+
+	private:
+        Key driveKey_;
+        Amount storageUnits_;
+	};
+
+	extern template class TStoragePaymentTransaction<Transaction>;
+	extern template class TStoragePaymentTransaction<EmbeddedTransaction>;
+
+	using StoragePaymentTransaction = TStoragePaymentTransaction<Transaction>;
+	using EmbeddedStoragePaymentTransaction = TStoragePaymentTransaction<EmbeddedTransaction>;
+
+	/// Creates storage payment transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+	std::unique_ptr<StoragePaymentTransaction>
+    CreateStoragePaymentTransaction(const Key& driveKey,
+                                    const Amount& storageUnits,
+                                    std::optional<Amount> maxFee = std::nullopt,
+                                    std::optional<NetworkDuration> deadline = std::nullopt,
+                                    std::optional<NetworkIdentifier> networkId = std::nullopt);
+
+
+	/// Creates storage payment transaction.
+	/// \note Throws \c transaction_error if mosaics or message have invalid size.
+	/// \note Optional transaction parameters are initialized using \c Config if not set explicitly.
+    std::unique_ptr<EmbeddedStoragePaymentTransaction>
+    CreateEmbeddedStoragePaymentTransaction(const Key& driveKey,
+                                            const Amount& storageUnits,
+                                            const Key& signer,
+                                            std::optional<NetworkIdentifier> networkId = std::nullopt);
+}

include/xpxchaincpp/model/transaction/transaction_type.h

@@ -28,12 +28,16 @@ namespace xpx_chain_sdk {
 		Transaction_Property = 0x4350,
 		Secret_Lock = 0x4152,
 		Secret_Proof = 0x4252,
+        Storage_Payment = 0x4a62,
 		Account_Link = 0x414C,
 		Prepare_Bc_Drive = 0x4162,
 		Data_Modification = 0x4262,
 		Download = 0x4362,
+		Download_Payment = 0x4962,
+        Drive_Closure = 0x4e62,
 		Data_Modification_Approval = 0x4462,
 		Data_Modification_Cancel = 0x4562,
+		Finish_Download = 0x4862,
 		Replicator_Onboarding = 0x4662,
 	};