// Copyright 2019-2025 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/>.

//! Precompile to receive GMP callbacks and forward to XCM

use parity_scale_codec::{Decode, Encode};

use precompile_utils::prelude::*;

use sp_core::{H256, U256};

use sp_std::vec::Vec;

// The Polkadot-sdk removed support for XCM Location V1, but the GMP precompile still needs to support it,

// so we have to wrap VersionedLocation to re-add support for XCM Location V1.

pub enum VersionedLocation {

	#[codec(index = 1)] // v2 is same as v1 and therefore re-using the v1 index

	V2(deprecated_xcm_v2::MultiLocationV2),

	#[codec(index = 3)]

	V3(xcm::v3::MultiLocation),

	#[codec(index = 4)]

	V4(xcm::v4::Location),

	#[codec(index = 5)]

	V5(xcm::v5::Location),

}

impl TryFrom<VersionedLocation> for xcm::latest::Location {

	type Error = ();

			}

		}

}

// A user action which will attempt to route the transferred assets to the account/chain specified

// by the given Location. Recall that a Location can contain both a chain and an account

// on that chain, as this one should.

#[derive(Encode, Decode, Debug)]

pub struct XcmRoutingUserAction {

	pub destination: VersionedLocation,

}

// A user action which is the same as XcmRoutingUserAction but also allows a fee to be paid. The

// fee is paid in the same asset being transferred, and must be <= the amount being sent.

#[derive(Encode, Decode, Debug)]

pub struct XcmRoutingUserActionWithFee {

	pub destination: VersionedLocation,

	pub fee: U256,

}

// A simple versioning wrapper around the initial XcmRoutingUserAction use-case. This should make

// future breaking changes easy to add in a backwards-compatible way.

#[non_exhaustive]

pub enum VersionedUserAction {

	V1(XcmRoutingUserAction),

	V2(XcmRoutingUserActionWithFee),

}

// Struct representing a Wormhole VM

// The main purpose of this struct is to decode the ABI encoded struct returned from certain calls

// in the Wormhole Ethereum contracts.

//

// https://github.com/wormhole-foundation/wormhole/blob/main/ethereum/contracts/Structs.sol

pub struct WormholeVM {

	pub version: u8,

	pub timestamp: u32,

	pub nonce: u32,

	pub emitter_chain_id: u16,

	pub emitter_address: H256,

	pub sequence: u64,

	pub consistency_level: u8,

	pub payload: BoundedBytes<crate::GetCallDataLimit>,

	pub guardian_set_index: u32,

	pub signatures: Vec<WormholeSignature>, // TODO: review: can this allow unbounded allocations?

	pub hash: H256,

}

// Struct representing a Wormhole Signature struct

pub struct WormholeSignature {

	pub r: U256,

	pub s: U256,

	pub v: u8,

	pub guardian_index: u8,

}

// Struct representing a wormhole "BridgeStructs.TransferWithPayload" struct

// As with WormholeVM, the main purpose of this struct is to decode the ABI encoded struct when it

// returned from calls to Wormhole Ethereum contracts.

pub struct WormholeTransferWithPayloadData {

	pub payload_id: u8,

	pub amount: U256,

	pub token_address: H256,

	pub token_chain: u16,

	pub to: H256,

	pub to_chain: u16,

	pub from_address: H256,

	pub payload: BoundedBytes<crate::GetCallDataLimit>,

}

/// Reimplement the deprecated xcm v2 Location types to allow for backwards compatibility

mod deprecated_xcm_v2 {

	use super::*;

	#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]

	pub struct MultiLocationV2 {

		pub parents: u8,

		pub interior: JunctionsV2,

	}

	impl TryFrom<MultiLocationV2> for xcm::v3::MultiLocation {

		type Error = ();

			))

	}

	pub enum JunctionsV2 {

		Here,

		/// A relative path comprising 1 junction.

		X1(JunctionV2),

		/// A relative path comprising 2 junctions.

		X2(JunctionV2, JunctionV2),

		/// A relative path comprising 3 junctions.

		X3(JunctionV2, JunctionV2, JunctionV2),

		/// A relative path comprising 4 junctions.

		X4(JunctionV2, JunctionV2, JunctionV2, JunctionV2),

		/// A relative path comprising 5 junctions.

		X5(JunctionV2, JunctionV2, JunctionV2, JunctionV2, JunctionV2),

		/// A relative path comprising 6 junctions.

		X6(

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

		),

		/// A relative path comprising 7 junctions.

		X7(

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

		),

		/// A relative path comprising 8 junctions.

		X8(

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

			JunctionV2,

		),

	}

	impl TryFrom<JunctionsV2> for xcm::v3::Junctions {

		type Error = ();

			use JunctionsV2::*;

				),

				),

				),

				),

				),

			})

	}

	pub enum JunctionV2 {

		/// An indexed parachain belonging to and operated by the context.

		///

		/// Generally used when the context is a Polkadot Relay-chain.

		Parachain(#[codec(compact)] u32),

		/// A 32-byte identifier for an account of a specific network that is respected as a sovereign

		/// endpoint within the context.

		///

		/// Generally used when the context is a Substrate-based chain.

		AccountId32 { network: NetworkIdV2, id: [u8; 32] },

		/// An 8-byte index for an account of a specific network that is respected as a sovereign

		/// endpoint within the context.

		///

		/// May be used when the context is a Frame-based chain and includes e.g. an indices pallet.

		AccountIndex64 {

			network: NetworkIdV2,

			#[codec(compact)]

			index: u64,

		},

		/// A 20-byte identifier for an account of a specific network that is respected as a sovereign

		/// endpoint within the context.

		///

		/// May be used when the context is an Ethereum or Bitcoin chain or smart-contract.

		AccountKey20 { network: NetworkIdV2, key: [u8; 20] },

		/// An instanced, indexed pallet that forms a constituent part of the context.

		///

		/// Generally used when the context is a Frame-based chain.

		PalletInstance(u8),

		/// A non-descript index within the context location.

		///

		/// Usage will vary widely owing to its generality.

		///

		/// NOTE: Try to avoid using this and instead use a more specific item.

		GeneralIndex(#[codec(compact)] u128),

		/// A nondescript datum acting as a key within the context location.

		///

		/// Usage will vary widely owing to its generality.

		///

		/// NOTE: Try to avoid using this and instead use a more specific item.

		GeneralKey(sp_runtime::WeakBoundedVec<u8, sp_core::ConstU32<32>>),

		///

		/// Not currently used except as a fallback when deriving ancestry.

		OnlyChild,

		// The GMP precompile doesn't need to support Plurality Junction

		//Plurality { id: BodyId, part: BodyPart },

	}

	impl TryFrom<JunctionV2> for xcm::v3::Junction {

		type Error = ();

			use JunctionV2::*;

				},

			})

	}

	pub enum NetworkIdV2 {

		Any,

		/// Some named network.

		Named(sp_runtime::WeakBoundedVec<u8, sp_core::ConstU32<32>>),

		Polkadot,

		Kusama,

	}

	impl From<NetworkIdV2> for Option<xcm::v3::NetworkId> {

			use NetworkIdV2::*;

			}

	}

}

#[cfg(test)]

mod tests {

	use super::*;

	#[test]

}