// Copyright (C) Moondance Labs Ltd.

// This file is part of Tanssi.

// Tanssi 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.

// Tanssi 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 Tanssi.  If not, see <http://www.gnu.org/licenses/>

//! EthereumTokenTransfers pallet.

//!

//! This pallet takes care of sending the native Starlight token from Starlight to Ethereum.

//!

//! It does this by sending a MintForeignToken command to Ethereum through a

//! specific channel_id (which is also stored in this pallet).

//!

//! ## Extrinsics:

//!

//! ### set_token_transfer_channel:

//!

//! Only callable by root. Used to specify which channel_id

//! will be used to send the tokens through. It also receives the para_id and

//! agent_id params corresponding to the channel specified.

//!

//! ### transfer_native_token:

//!

//! Used to perform the actual sending of the tokens, it requires to specify an amount and a recipient,

//! which is a H160 account on the Ethereum side.

//!

//! Inside it, the message is built using the MintForeignToken command. Once the message is validated,

//! the amount is transferred from the caller to the EthereumSovereignAccount. This allows to prevent

//! double-spending and to track how much of the native token is sent to Ethereum.

//!

//! After that, the message is delivered to Ethereum through the T::OutboundQueue implementation.

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

extern crate alloc;

#[cfg(test)]

mod mock;

#[cfg(test)]

mod tests;

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

mod benchmarking;

pub mod weights;

pub mod origins;

use {

    alloc::vec,

    frame_support::{

        pallet_prelude::*,

        traits::{

            fungible::{self, Inspect, Mutate},

            tokens::Preservation,

            Get,

        },

    },

    frame_system::pallet_prelude::*,

    snowbridge_core::{reward::MessageId, AgentId, ChannelId, ParaId, TokenId},

    snowbridge_outbound_queue_primitives::v1::{

        Command as SnowbridgeCommand, Message as SnowbridgeMessage, SendMessage,

    },

    snowbridge_outbound_queue_primitives::SendError,

    sp_core::{H160, H256},

    sp_runtime::{traits::MaybeEquivalence, DispatchResult},

    tp_bridge::{ChannelInfo, EthereumSystemChannelManager, TicketInfo},

    xcm::prelude::*,

};

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

use tp_bridge::TokenChannelSetterBenchmarkHelperTrait;

pub use pallet::*;

pub type BalanceOf<T> =

    <<T as pallet::Config>::Currency as Inspect<<T as frame_system::Config>::AccountId>>::Balance;

#[frame_support::pallet]

pub mod pallet {

    use super::*;

    pub use crate::weights::WeightInfo;

    /// The current storage version.

    const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);

    pub type RewardPoints = u32;

    pub type EraIndex = u32;

    #[pallet::config]

    pub trait Config: frame_system::Config {

        /// Currency to handle fees and internal native transfers.

        type Currency: fungible::Inspect<Self::AccountId, Balance: From<u128>>

            + fungible::Mutate<Self::AccountId>;

        /// Validate and send a message to Ethereum.

        type OutboundQueue: SendMessage<Balance = BalanceOf<Self>, Ticket: TicketInfo>;

        /// Handler for EthereumSystem pallet. Commonly used to manage channel creation.

        type EthereumSystemHandler: EthereumSystemChannelManager;

        /// Ethereum sovereign account, where native transfers will go to.

        type EthereumSovereignAccount: Get<Self::AccountId>;

        /// Account in which fees will be minted.

        type FeesAccount: Get<Self::AccountId>;

        /// Token Location from the external chain's point of view.

        type TokenLocationReanchored: Get<Location>;

        /// How to convert from a given Location to a specific TokenId.

        type TokenIdFromLocation: MaybeEquivalence<TokenId, Location>;

        /// The weight information of this pallet.

        type WeightInfo: WeightInfo;

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

        type BenchmarkHelper: TokenChannelSetterBenchmarkHelperTrait;

        /// Tip Handler which is used for adding tips to the EthereumSystemV2 transaction.

        type TipHandler: TipHandler<Self::PalletOrigin>;

        type PalletOrigin: From<Origin<Self>>;

    }

    pub trait TipHandler<Origin> {

        fn add_tip(origin: Origin, message_id: MessageId, amount: u128) -> DispatchResult;

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

        fn set_tip(_origin: Origin, _message_id: MessageId, _amount: u128) {}

    }

    // Events

    #[pallet::event]

    #[pallet::generate_deposit(pub(super) fn deposit_event)]

    pub enum Event<T: Config> {

        /// Information for the channel was set properly.

        ChannelInfoSet { channel_info: ChannelInfo },

        /// Some native token was successfully transferred to Ethereum.

        NativeTokenTransferred {

            message_id: H256,

            channel_id: ChannelId,

            source: T::AccountId,

            recipient: H160,

            token_id: H256,

            amount: u128,

            fee: BalanceOf<T>,

        },

    }

    // Errors

    #[pallet::error]

    pub enum Error<T> {

        /// The channel's information has not been set on this pallet yet.

        ChannelInfoNotSet,

        /// Conversion from Location to TokenId failed.

        UnknownLocationForToken,

        /// The outbound message is invalid prior to send.

        InvalidMessage(SendError),

        /// The outbound message could not be sent.

        TransferMessageNotSent(SendError),

        /// When add_tip extrinsic could not be called.

        TipFailed,

    }

    #[pallet::pallet]

    #[pallet::storage_version(STORAGE_VERSION)]

    pub struct Pallet<T>(_);

    // Storage

    #[pallet::storage]

    #[pallet::getter(fn current_channel_info)]

    pub type CurrentChannelInfo<T: Config> = StorageValue<_, ChannelInfo, OptionQuery>;

    #[derive(

        PartialEq,

        Eq,

        Clone,

        MaxEncodedLen,

        Encode,

        Decode,

        DecodeWithMemTracking,

        TypeInfo,

        RuntimeDebug,

    )]

    #[pallet::origin]

    pub enum Origin<T: Config> {

        /// The origin for the pallet to make extrinsics.

        EthereumTokenTransfers(T::AccountId),

    }

    // Calls

    #[pallet::call]

    impl<T: Config> Pallet<T> {

        #[pallet::call_index(0)]

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

        pub fn set_token_transfer_channel(

            origin: OriginFor<T>,

            channel_id: ChannelId,

            agent_id: AgentId,

            para_id: ParaId,

        }

        #[pallet::call_index(1)]

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

        pub fn transfer_native_token(

            origin: OriginFor<T>,

            amount: u128,

            recipient: H160,

            // Transfer fees to FeesAccount.

            // Transfer amount to Ethereum's sovereign account.

        }

        #[pallet::call_index(2)]

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

        pub fn add_tip(

            origin: OriginFor<T>,

            message_id: MessageId,

            amount: u128,

        }

    }

}

pub struct DenyTipHandler<T>(core::marker::PhantomData<T>);

impl<T, Origin> TipHandler<Origin> for DenyTipHandler<T> {

    #[cfg(not(feature = "runtime-benchmarks"))]

    // in order for the extrinsic to still be benchmarkable, we implement it empty

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

    fn add_tip(_origin: Origin, _message_id: MessageId, _amount: u128) -> DispatchResult {

        Ok(())

    }

}