// Copyright 2019-2022 PureStake Inc.

// This file is part of Moonbeam.

// Moonbeam is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// Moonbeam is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with Moonbeam.  If not, see <http://www.gnu.org/licenses/>.

//! # Xcm Transactor Module

//!

//! ## Overview

//!

//! Module to provide transact capabilities on other chains

//!

//! In this pallet we will make distinctions between sovereign, derivative accounts and

//! multilocation-based derived accounts. The first is the account the parachain controls

//! in the destination chain, the second is an account derived from the

//! sovereign account itself, e.g., by hashing it with an index, while the third is an account

//! derived from the multilocation of a use in this chain (tipically, hashing the ML).

//! Such distinction is important since we want to keep the integrity of the sovereign account

//!

//! This pallet provides three ways of sending Transact operations to another chain

//!

//! - transact_through_derivative: Transact through an address derived from this chains sovereign

//! 	account in the destination chain. For the transaction to successfully be dispatched in the

//! 	destination chain, pallet-utility needs to be installed and at least paid xcm message

//! 	execution should be allowed (and WithdrawAsset,BuyExecution and Transact messages allowed)

//! 	in the destination chain

//!

//!

//!

//! 	The transactions are dispatched from a derivative account

//! 	of the sovereign account

//! 	This pallet only stores the index of the derivative account used, but

//! 	not the derivative account itself. The only assumption this pallet makes

//! 	is the existence of the pallet_utility pallet in the destination chain

//! 	through the XcmTransact trait.

//!

//! 	All calls will be wrapped around utility::as_derivative. This makes sure

//! 	the inner call is executed from the derivative account and not the sovereign

//! 	account itself.

//!

//! 	Index registration happens through DerivativeAddressRegistrationOrigin.

//! 	This derivative account can be funded by external users to

//! 	ensure it has enough funds to make the calls

//!

//! - transact_through_sovereign: Transact through the sovereign account representing this chain.

//! 	For the transaction to successfully be dispatched in the destination chain, at least paid

//! 	xcm message execution should be allowed (and WithdrawAsset,BuyExecution and Transact

//! 	messages allowed) in the destination chain. Only callable by Root

//!

//! - transact_through_signed: Transact through an account derived from the multilocation

//! 	representing the signed user making the call. We ensure this by prepending DescendOrigin as

//! 	the first instruction of the XCM message. For the transaction to successfully be dispatched

//! 	in the destination chain, at least descended paid xcm message execution should be allowed

//! 	(and DescendOrigin + WithdrawAsset + BuyExecution + Transact messages allowed) in the

//! 	destination chain. Additionally, a ML-based derivation mechanism needs to be implemented

//! 	in the destination chain.

#![cfg_attr(not(feature = "std"), no_std)]

use frame_support::pallet;

pub use pallet::*;

#[cfg(any(test, feature = "runtime-benchmarks"))]

mod benchmarks;

#[cfg(test)]

pub(crate) mod mock;

#[cfg(test)]

mod tests;

pub mod encode;

pub mod migrations;

pub mod relay_indices;

pub mod weights;

pub use crate::weights::WeightInfo;

type CurrencyIdOf<T> = <T as Config>::CurrencyId;

pub mod pallet {

	use super::*;

	use crate::relay_indices::RelayChainIndices;

	use crate::weights::WeightInfo;

	use crate::CurrencyIdOf;

	use cumulus_primitives_core::{relay_chain::HrmpChannelId, ParaId};

	use frame_support::traits::EitherOfDiverse;

	use frame_support::{

		dispatch::DispatchResult, pallet_prelude::*, weights::constants::WEIGHT_REF_TIME_PER_SECOND,

	};

	use frame_system::{ensure_signed, pallet_prelude::*};

	use sp_runtime::traits::{AtLeast32BitUnsigned, Bounded, Convert};

	use sp_std::boxed::Box;

	use sp_std::convert::TryFrom;

	use sp_std::prelude::*;

	use sp_std::vec::Vec;

	use xcm::{latest::prelude::*, VersionedLocation};

	use xcm_executor::traits::{TransactAsset, WeightBounds};

	use xcm_primitives::{

		FilterMaxAssetFee, HrmpAvailableCalls, HrmpEncodeCall, Reserve, UtilityAvailableCalls,

		UtilityEncodeCall, XcmTransact,

	};

	pub struct Pallet<T>(pub PhantomData<T>);

	#[pallet::config]

	pub trait Config: frame_system::Config {

		type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;

		/// The balance type.

		type Balance: Parameter

			+ Member

			+ AtLeast32BitUnsigned

			+ Default

			+ Copy

			+ MaybeSerializeDeserialize

			+ Into<u128>;

		/// Currency Id.

		type CurrencyId: Parameter + Member + Clone;

		/// Convert `T::CurrencyId` to `Location`.

		type CurrencyIdToLocation: Convert<Self::CurrencyId, Option<Location>>;

		// XcmTransact needs to be implemented. This type needs to implement

		// utility call encoding and multilocation gathering

		type Transactor: Parameter + Member + Clone + XcmTransact;

		/// AssetTransactor allows us to withdraw asset without being trapped

		/// This should change in xcm v3, which allows us to burn assets

		type AssetTransactor: TransactAsset;

		// The origin that is allowed to register derivative address indices

		type DerivativeAddressRegistrationOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		// The origin that is allowed to manipulate (open, close, accept, cancel) an Hrmp channel

		type HrmpManipulatorOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		// The origin that is allowed to open and accept an Hrmp channel

		type HrmpOpenOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// Convert `T::AccountId` to `Location`.

		type AccountIdToLocation: Convert<Self::AccountId, Location>;

		/// Means of measuring the weight consumed by an XCM message locally.

		type Weigher: WeightBounds<Self::RuntimeCall>;

		/// This chain's Universal Location.

		type UniversalLocation: Get<InteriorLocation>;

		/// Self chain location.

		#[pallet::constant]

		type SelfLocation: Get<Location>;

		// The origin that is allowed to dispatch calls from the sovereign account directly

		type SovereignAccountDispatcherOrigin: EnsureOrigin<Self::RuntimeOrigin>;

		/// XCM sender.

		type XcmSender: SendXcm;

		// Base XCM weight.

		///

		/// The actual weight for an XCM message is `T::BaseXcmWeight +

		/// T::Weigher::weight(&msg)`.

		#[pallet::constant]

		type BaseXcmWeight: Get<Weight>;

		/// The way to retrieve the reserve of a Asset. This can be

		/// configured to accept absolute or relative paths for self tokens

		type ReserveProvider: xcm_primitives::Reserve;

		/// The way to filter the max fee to use for HRMP management operations

		type MaxHrmpFee: FilterMaxAssetFee;

		type WeightInfo: WeightInfo;

	}

	/// Stores the information to be able to issue a transact operation in another chain use an

	/// asset as fee payer.

	#[derive(

		Default,

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

	)]

	pub struct RemoteTransactInfoWithMaxWeight {

		/// Extra weight that transacting a call in a destination chain adds

		/// Extra weight involved when transacting without DescendOrigin

		/// This should always be possible in a destination chain, since

		/// it involves going through the sovereign account

		pub transact_extra_weight: Weight,

		/// Max destination weight

		pub max_weight: Weight,

		/// Whether we allow transacting through signed origins in another chain, and

		/// how much extra cost implies

		/// Extra weight involved when transacting with DescendOrigin

		/// The reason for it being an option is because the destination chain

		/// might not support constructing origins based on generic MultiLocations

		pub transact_extra_weight_signed: Option<Weight>,

	}

	/// Enum defining the way to express a Currency.

	pub enum Currency<CurrencyId> {

		// Express the Currency as a CurrencyId

		// Express the Currency as its MultiLOcation

	}

	impl<T> Default for Currency<T> {

	}

	pub struct HrmpInitParams {

		pub para_id: ParaId,

		pub proposed_max_capacity: u32,

		pub proposed_max_message_size: u32,

	}

	/// Enum defining the way to express a Currency.

	pub enum HrmpOperation {

			para_id: ParaId,

		},

			channel_id: HrmpChannelId,

			open_requests: u32,

		},

	}

	#[derive(

		Default,

		Clone,

		Encode,

		Decode,

		Eq,

		PartialEq,

	)]

	/// Struct that defines how to express the payment in a particular currency

	/// currency is defined by the Currency enum, which can be expressed as:

	/// - CurrencyId

	/// - Location

	///

	/// The fee_amount is an option. In case of None, the fee will be tried to

	/// be calculated from storage. If the storage item for the currency is not

	/// populated, then it fails

	pub struct CurrencyPayment<CurrencyId> {

		// the currency in which we want to express our payment

		pub currency: Currency<CurrencyId>,

		// indicates whether we want to specify the fee amount to be used

		pub fee_amount: Option<u128>,

	}

	/// Struct tindicating information about transact weights

	/// It allows to specify:

	/// - transact_required_weight_at_most: the amount of weight the Transact instruction

	///   should consume at most

	/// - overall_weight: the overall weight to be used for the whole XCM message execution.

	///   If None, then this amount will be tried to be derived from storage.  If the storage item

	pub struct TransactWeights {

		// the amount of weight the Transact instruction should consume at most

		pub transact_required_weight_at_most: Weight,

		// the overall weight to be used for the whole XCM message execution. If None,

		// then this amount will be tried to be derived from storage.  If the storage item

		// for the chain is not populated, then it fails

		pub overall_weight: Option<WeightLimit>,

	}

	/// The amount of ref_time and proof_size to use for fee calculation if

	/// we are dealing with an Unlimited variant inside 'overall_weight' field

	/// of 'TransactWeights' struct.

	pub const MAX_WEIGHT: Weight = Weight::from_parts(100_000_000_000, 100_000);

	/// Since we are using pallet-utility for account derivation (through AsDerivative),

	/// we need to provide an index for the account derivation. This storage item stores the index

	/// assigned for a given local account. These indices are usable as derivative in the relay chain

	#[pallet::getter(fn index_to_account)]

	pub type IndexToAccount<T: Config> = StorageMap<_, Blake2_128Concat, u16, T::AccountId>;

	/// Stores the transact info of a Location. This defines how much extra weight we need to

	/// add when we want to transact in the destination chain and maximum amount of weight allowed

	/// by the destination chain

	#[pallet::getter(fn transact_info)]

	pub type TransactInfoWithWeightLimit<T: Config> =

		StorageMap<_, Blake2_128Concat, Location, RemoteTransactInfoWithMaxWeight>;

	/// Stores the fee per second for an asset in its reserve chain. This allows us to convert

	/// from weight to fee

	#[pallet::getter(fn dest_asset_fee_per_second)]

	pub type DestinationAssetFeePerSecond<T: Config> = StorageMap<_, Twox64Concat, Location, u128>;

	/// Stores the indices of relay chain pallets

	#[pallet::getter(fn relay_indices)]

	pub type RelayIndices<T: Config> = StorageValue<_, RelayChainIndices, ValueQuery>;

	/// An error that can occur while executing the mapping pallet's logic.

	pub enum Error<T> {

	}

	pub enum Event<T: Config> {

		TransactedDerivative {

			account_id: T::AccountId,

			dest: Location,

			call: Vec<u8>,

			index: u16,

		},

		TransactedSovereign {

			fee_payer: Option<T::AccountId>,

			dest: Location,

			call: Vec<u8>,

		},

		TransactedSigned {

			fee_payer: T::AccountId,

			dest: Location,

			call: Vec<u8>,

		},

		RegisteredDerivative {

			account_id: T::AccountId,

			index: u16,

		},

			index: u16,

		},

		TransactFailed {

			error: XcmError,

		},

		TransactInfoChanged {

			location: Location,

			remote_info: RemoteTransactInfoWithMaxWeight,

		},

		TransactInfoRemoved {

			location: Location,

		},

		DestFeePerSecondChanged {

			location: Location,

			fee_per_second: u128,

		},

		DestFeePerSecondRemoved {

			location: Location,

		},

		HrmpManagementSent {

			action: HrmpOperation,

		},

	}

	#[pallet::genesis_config]

	pub struct GenesisConfig<T> {

		pub relay_indices: RelayChainIndices,

		pub _phantom: PhantomData<T>,

	}

	impl<T> Default for GenesisConfig<T> {

	}

	impl<T: Config> BuildGenesisConfig for GenesisConfig<T> {

	}

	impl<T: Config> Pallet<T> {

		/// Register a derivative index for an account id. Dispatchable by

		/// DerivativeAddressRegistrationOrigin

		///

		/// We do not store the derivative address, but only the index. We do not need to store

		/// the derivative address to issue calls, only the index is enough

		///

		/// For now an index is registered for all possible destinations and not per-destination.

		/// We can change this in the future although it would just make things more complicated

		#[pallet::call_index(0)]

		#[pallet::weight(T::WeightInfo::register())]

			);

		}

		/// De-Register a derivative index. This prevents an account to use a derivative address

		/// (represented by an index) from our of our sovereign accounts anymore

		#[pallet::call_index(1)]

		#[pallet::weight(T::WeightInfo::deregister())]

			// Remove index

		}

		/// Transact the inner call through a derivative account in a destination chain,

		/// using 'fee_location' to pay for the fees. This fee_location is given as a multilocation

		///

		/// The caller needs to have the index registered in this pallet. The fee multiasset needs

		/// to be a reserve asset for the destination transactor::multilocation.

		#[pallet::call_index(2)]

		#[pallet::weight(

			Pallet::<T>::weight_of_initiate_reserve_withdraw()

			.saturating_add(T::WeightInfo::transact_through_derivative())

		)]

		pub fn transact_through_derivative(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: T::Transactor,

			// derivative index to be used

			index: u16,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// inner call to be executed in destination. This wiol

			// be wrapped into utility.as_derivative

			inner_call: Vec<u8>,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// The index exists

			// The derivative index is owned by the origin

			// Encode call bytes

			// We make sure the inner call is wrapped on a as_derivative dispatchable

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Calculate fee based on FeePerSecond

			// If refund is true, the appendix instruction will be a deposit back to the sovereign

					])

			// Deposit event

		}

		/// Transact the call through the sovereign account in a destination chain,

		/// 'fee_payer' pays for the fee

		///

		/// SovereignAccountDispatcherOrigin callable only

		#[pallet::call_index(3)]

		#[pallet::weight(

			Pallet::<T>::weight_of_initiate_reserve_withdraw()

			.saturating_add(T::WeightInfo::transact_through_sovereign())

		)]

		pub fn transact_through_sovereign(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: Box<VersionedLocation>,

			// account paying for fees

			fee_payer: Option<T::AccountId>,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// call to be executed in destination

			call: Vec<u8>,

			// origin kind to be used

			origin_kind: OriginKind,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Calculate fee based on FeePerSecond and total_weight

			// If refund is true, the appendix instruction will be a deposit back to the sovereign

					])

			// Grab the destination

			// Deposit event

		}

		/// Change the transact info of a location

		#[pallet::call_index(4)]

		#[pallet::weight(T::WeightInfo::set_transact_info())]

		pub fn set_transact_info(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

			transact_extra_weight: Weight,

			max_weight: Weight,

			transact_extra_weight_signed: Option<Weight>,

		}

		/// Remove the transact info of a location

		#[pallet::call_index(5)]

		#[pallet::weight(T::WeightInfo::remove_transact_info())]

		pub fn remove_transact_info(

			origin: OriginFor<T>,

			location: Box<VersionedLocation>,

			// Remove transact info

		}

		/// Transact the call through the a signed origin in this chain

		/// that should be converted to a transaction dispatch account in the destination chain

		/// by any method implemented in the destination chains runtime

		///

		/// This time we are giving the currency as a currencyId instead of multilocation

		#[pallet::call_index(6)]

		#[pallet::weight(T::WeightInfo::transact_through_signed())]

		pub fn transact_through_signed(

			origin: OriginFor<T>,

			// destination to which the message should be sent

			dest: Box<VersionedLocation>,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// call to be executed in destination

			call: Vec<u8>,

			// weight information to be used

			weight_info: TransactWeights,

			// add RefundSurplus and DepositAsset appendix

			refund: bool,

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			// Fee to be paid

			// If refund is true, the appendix instruction will be a deposit back to the sender

					])

			// Grab the destination

			// Deposit event

		}

		/// Set the fee per second of an asset on its reserve chain

		#[pallet::call_index(7)]

		#[pallet::weight(T::WeightInfo::set_fee_per_second())]

		pub fn set_fee_per_second(

			origin: OriginFor<T>,

			asset_location: Box<VersionedLocation>,

			fee_per_second: u128,

		}

		/// Remove the fee per second of an asset on its reserve chain

		#[pallet::call_index(8)]

		#[pallet::weight(T::WeightInfo::set_fee_per_second())]

		pub fn remove_fee_per_second(

			origin: OriginFor<T>,

			asset_location: Box<VersionedLocation>,

		}

		/// Manage HRMP operations

		#[pallet::call_index(9)]

		#[pallet::weight(T::WeightInfo::hrmp_manage())]

		pub fn hrmp_manage(

			origin: OriginFor<T>,

			action: HrmpOperation,

			// fee to be used

			fee: CurrencyPayment<CurrencyIdOf<T>>,

			// weight information to be used

			weight_info: TransactWeights,

				HrmpOperation::InitOpen(_) | HrmpOperation::Accept { .. } => {

				}

				HrmpOperation::Close(_) | HrmpOperation::Cancel { .. } => {

				}

			}

			// process action

				}

				}

				}

				HrmpOperation::Cancel {

			}

			// Grab the destination

			// For hrmp, it is always parent

			// Calculate the total weight that the xcm message is going to spend in the

			// destination chain

			};

			);

			// The appendix instruction will be a deposit back to a self location

		}

	}

	impl<T: Config> Pallet<T> {

				// Convert origin to multilocation

			// Construct the transact message. This is composed of WithdrawAsset||BuyExecution||

			// Transact.

			// WithdrawAsset: Withdraws "amount" from the sovereign account. These tokens will be

			// used to pay fees

			// BuyExecution: Buys "execution power" in the destination chain

			// Transact: Issues the transaction

			// Send to sovereign

			// Construct the transact message. This is composed of WithdrawAsset||BuyExecution||

			// Transact.

			// WithdrawAsset: Withdraws "amount" from the sovereign account. These tokens will be

			// used to pay fees

			// BuyExecution: Buys "execution power" in the destination chain

			// Transact: Issues the transaction

			// We append DescendOrigin as the first instruction in the message

			// The new message looks like DescendOrigin||WithdrawAsset||BuyExecution||

			// Transact.

			// Send to destination chain

		/// Calculate the amount of fee based on the multilocation of the fee asset and

		/// the total weight to be spent

			// If amount is provided, just use it

			// Else, multiply weight*destination_units_per_second to see how much we should charge for

			// this weight execution

			// Construct Asset

		/// Construct the transact xcm message with the provided parameters

			];

		/// Construct a buy execution xcm order with the provided parameters

		/// Construct a withdraw instruction from a sovereign account

		/// Construct a deposit instruction to a sovereign account

		/// Construct a withdraw instruction from a sovereign account

		/// Ensure `dest` has chain part and none recipient part.

			} else {

			}

		/// Check whether the transfer is allowed.

		///

		/// Returns `Err` if `asset` is not a reserved asset of `dest`,

		/// else returns `dest`, parachain or relay chain location.

			// We only allow to transact using a reserve asset as fee

		/// Returns weight of `weight_of_initiate_reserve_withdraw` call.

		/// Returns the fee for a given set of parameters

		/// We always round up in case of fractional division

		/// Returns the weight information for a destination from storage

		/// it returns the weight to be used in non-signed cases

			// Grab transact info for the destination provided

			);

		/// Returns the weight information for a destination from storage

		/// it returns the weight to be used in signed cases

			// Grab transact info for the destination provided

			// If this storage item is not set, it means that the destination chain

			// does not support this kind of transact message

			);

		/// Returns the fee per second charged by a reserve chain for an asset

		/// it takes this information from storage

			// Ensure the asset is a reserve

			// We only store information about asset fee per second on its reserve chain

			// if amount is provided, we first check whether we have this information

		/// Converts Currency to multilocation

			}

	}

}