// This file is part of Substrate.

// Copyright (C) Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// 	http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

use crate::{Config, Key};

use codec::{Decode, Encode};

use core::{fmt, marker::PhantomData};

use frame_support::{dispatch::DispatchInfo, ensure};

use scale_info::TypeInfo;

use sp_runtime::{

	traits::{DispatchInfoOf, Dispatchable, SignedExtension},

	transaction_validity::{

		InvalidTransaction, TransactionPriority, TransactionValidity, TransactionValidityError,

		UnknownTransaction, ValidTransaction,

	},

};

/// Ensure that signed transactions are only valid if they are signed by sudo account.

///

/// In the initial phase of a chain without any tokens you can not prevent accounts from sending

/// transactions.

/// These transactions would enter the transaction pool as the succeed the validation, but would

/// fail on applying them as they are not allowed/disabled/whatever. This would be some huge dos

/// vector to any kind of chain. This extension solves the dos vector by preventing any kind of

/// transaction entering the pool as long as it is not signed by the sudo account.

#[scale_info(skip_type_params(T))]

pub struct CheckOnlySudoAccount<T: Config + Send + Sync>(PhantomData<T>);

impl<T: Config + Send + Sync> Default for CheckOnlySudoAccount<T> {

}

impl<T: Config + Send + Sync> fmt::Debug for CheckOnlySudoAccount<T> {

	#[cfg(feature = "std")]

	#[cfg(not(feature = "std"))]

	fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {

		Ok(())

	}

}

impl<T: Config + Send + Sync> CheckOnlySudoAccount<T> {

	/// Creates new `SignedExtension` to check sudo key.

}

impl<T: Config + Send + Sync> SignedExtension for CheckOnlySudoAccount<T>

where

	<T as Config>::RuntimeCall: Dispatchable<Info = DispatchInfo>,

{

	const IDENTIFIER: &'static str = "CheckOnlySudoAccount";

	type AccountId = T::AccountId;

	type Call = <T as Config>::RuntimeCall;

	type AdditionalSigned = ();

	type Pre = ();

}