Polkadot assets on ethereum

bridges/snowbridge/pallets/inbound-queue/src/mock.rs

@@ -14,12 +14,12 @@ use snowbridge_beacon_primitives::{
 use snowbridge_core::{
 	gwei,
 	inbound::{Log, Proof, VerificationError},
-	meth, Channel, ChannelId, PricingParameters, Rewards, StaticLookup,
+	meth, Channel, ChannelId, PricingParameters, Rewards, StaticLookup, TokenId,
 };
 use snowbridge_router_primitives::inbound::MessageToXcm;
 use sp_core::{H160, H256};
 use sp_runtime::{
-	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify},
+	traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, MaybeEquivalence, Verify},
 	BuildStorage, FixedU128, MultiSignature,
 };
 use sp_std::{convert::From, default::Default};
@@ -242,6 +242,16 @@ impl TransactAsset for SuccessfulTransactor {
 	}
 }
 
+pub struct MockTokenIdConvert;
+impl MaybeEquivalence<TokenId, Location> for MockTokenIdConvert {
+	fn convert(_id: &TokenId) -> Option<Location> {
+		Some(Location { parents: 1, interior: GlobalConsensus(Rococo).into() })
+	}
+	fn convert_back(_loc: &Location) -> Option<TokenId> {
+		None
+	}
+}
+
 impl inbound_queue::Config for Test {
 	type RuntimeEvent = RuntimeEvent;
 	type Verifier = MockVerifier;
@@ -255,6 +265,7 @@ impl inbound_queue::Config for Test {
 		InboundQueuePalletInstance,
 		AccountId,
 		Balance,
+		MockTokenIdConvert,
 	>;
 	type PricingParameters = Parameters;
 	type ChannelLookup = MockChannelLookup;

bridges/snowbridge/pallets/system/src/lib.rs

@@ -63,13 +63,16 @@ use frame_system::pallet_prelude::*;
 use snowbridge_core::{
 	meth,
 	outbound::{Command, Initializer, Message, OperatingMode, SendError, SendMessage},
-	sibling_sovereign_account, AgentId, Channel, ChannelId, ParaId,
-	PricingParameters as PricingParametersRecord, PRIMARY_GOVERNANCE_CHANNEL,
+	sibling_sovereign_account, token_id_of, AgentId, AssetRegistrarMetadata, Channel, ChannelId,
+	ParaId, PricingParameters as PricingParametersRecord, TokenId, PRIMARY_GOVERNANCE_CHANNEL,
 	SECONDARY_GOVERNANCE_CHANNEL,
 };
 use sp_core::{RuntimeDebug, H160, H256};
 use sp_io::hashing::blake2_256;
-use sp_runtime::{traits::BadOrigin, DispatchError, SaturatedConversion};
+use sp_runtime::{
+	traits::{BadOrigin, MaybeEquivalence},
+	DispatchError, SaturatedConversion,
+};
 use sp_std::prelude::*;
 use xcm::prelude::*;
 use xcm_executor::traits::ConvertLocation;
@@ -99,7 +102,7 @@ where
 }
 
 /// Hash the location to produce an agent id
-fn agent_id_of<T: Config>(location: &Location) -> Result<H256, DispatchError> {
+pub fn agent_id_of<T: Config>(location: &Location) -> Result<H256, DispatchError> {
 	T::AgentIdOf::convert_location(location).ok_or(Error::<T>::LocationConversionFailed.into())
 }
 
@@ -127,7 +130,7 @@ where
 
 #[frame_support::pallet]
 pub mod pallet {
-	use snowbridge_core::StaticLookup;
+	use snowbridge_core::{outbound::AgentExecuteCommand, StaticLookup};
 	use sp_core::U256;
 
 	use super::*;
@@ -211,6 +214,12 @@ pub mod pallet {
 		PricingParametersChanged {
 			params: PricingParametersOf<T>,
 		},
+		/// Register token
+		RegisterToken {
+			asset_id: Location,
+			token_id: H256,
+			agent_id: AgentId,
+		},
 	}
 
 	#[pallet::error]
@@ -226,6 +235,7 @@ pub mod pallet {
 		InvalidTokenTransferFees,
 		InvalidPricingParameters,
 		InvalidUpgradeParameters,
+		TokenExists,
 	}
 
 	/// The set of registered agents
@@ -243,6 +253,10 @@ pub mod pallet {
 	pub type PricingParameters<T: Config> =
 		StorageValue<_, PricingParametersOf<T>, ValueQuery, T::DefaultPricingParameters>;
 
+	#[pallet::storage]
+	#[pallet::getter(fn tokens)]
+	pub type Tokens<T: Config> = StorageMap<_, Twox64Concat, TokenId, Location, OptionQuery>;
+
 	#[pallet::genesis_config]
 	#[derive(frame_support::DefaultNoBound)]
 	pub struct GenesisConfig<T: Config> {
@@ -574,6 +588,57 @@ pub mod pallet {
 			});
 			Ok(())
 		}
+
+		/// Sends a message to the Gateway contract to register a new
+		/// token that represents `asset`.
+		///
+		/// - `origin`: Must be `MultiLocation` from sibling parachain
+		#[pallet::call_index(10)]
+		#[pallet::weight(T::WeightInfo::register_token())]
+		pub fn register_token(
+			origin: OriginFor<T>,
+			asset: Box<VersionedLocation>,
+			metadata: AssetRegistrarMetadata,
+		) -> DispatchResult {
+			let origin_location: Location = T::SiblingOrigin::ensure_origin(origin)?;
+
+			let (para_id, agent_id) = ensure_sibling::<T>(&origin_location)?;
+
+			let asset: Location =
+				(*asset).try_into().map_err(|_| Error::<T>::UnsupportedLocationVersion)?;
+
+			Self::do_register_token(para_id, agent_id, asset, metadata)?;
+
+			Ok(())
+		}
+
+		/// Sends a message to the Gateway contract to register a new
+		/// token that represents `asset`.
+		///
+		/// - `origin`: Must be `MultiLocation`
+		#[pallet::call_index(11)]
+		#[pallet::weight(T::WeightInfo::register_token())]
+		pub fn force_register_token(
+			origin: OriginFor<T>,
+			location: Box<VersionedLocation>,
+			asset: Box<VersionedLocation>,
+			metadata: AssetRegistrarMetadata,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			let location: Location =
+				(*location).try_into().map_err(|_| Error::<T>::UnsupportedLocationVersion)?;
+
+			let (para_id, agent_id) =
+				ensure_sibling::<T>(&location).map_err(|_| Error::<T>::InvalidLocation)?;
+
+			let asset: Location =
+				(*asset).try_into().map_err(|_| Error::<T>::UnsupportedLocationVersion)?;
+
+			Self::do_register_token(para_id, agent_id, asset, metadata)?;
+
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {
@@ -663,6 +728,41 @@ pub mod pallet {
 			let secondary_exists = Channels::<T>::contains_key(SECONDARY_GOVERNANCE_CHANNEL);
 			primary_exists && secondary_exists
 		}
+
+		pub(crate) fn do_register_token(
+			para_id: ParaId,
+			agent_id: AgentId,
+			asset_id: Location,
+			metadata: AssetRegistrarMetadata,
+		) -> Result<(), DispatchError> {
+			// Check that the channel exists
+			let channel_id: ChannelId = para_id.into();
+			ensure!(Channels::<T>::contains_key(channel_id), Error::<T>::NoChannel);
+
+			// Check that the agent exists
+			ensure!(Agents::<T>::contains_key(agent_id), Error::<T>::NoAgent);
+
+			// Record the token id or fail if it has already been created
+			let token_id = token_id_of(&asset_id);
+			ensure!(!Tokens::<T>::contains_key(token_id), Error::<T>::TokenExists);
+			Tokens::<T>::insert(token_id, asset_id.clone());
+
+			let command = Command::AgentExecute {
+				agent_id,
+				command: AgentExecuteCommand::RegisterToken {
+					token_id,
+					name: metadata.name,
+					symbol: metadata.symbol,
+					decimals: metadata.decimals,
+				},
+			};
+			let pays_fee = PaysFee::<T>::Yes(sibling_sovereign_account::<T>(para_id));
+			Self::send(channel_id, command, pays_fee)?;
+
+			Self::deposit_event(Event::<T>::RegisterToken { asset_id, token_id, agent_id });
+
+			Ok(())
+		}
 	}
 
 	impl<T: Config> StaticLookup for Pallet<T> {
@@ -684,4 +784,13 @@ pub mod pallet {
 			PricingParameters::<T>::get()
 		}
 	}
+
+	impl<T: Config> MaybeEquivalence<TokenId, Location> for Pallet<T> {
+		fn convert(id: &TokenId) -> Option<Location> {
+			Tokens::<T>::get(id)
+		}
+		fn convert_back(_loc: &Location) -> Option<TokenId> {
+			None
+		}
+	}
 }

bridges/snowbridge/pallets/system/src/weights.rs

@@ -42,6 +42,7 @@ pub trait WeightInfo {
 	fn force_transfer_native_from_agent() -> Weight;
 	fn set_token_transfer_fees() -> Weight;
 	fn set_pricing_parameters() -> Weight;
+	fn register_token() -> Weight;
 }
 
 // For backwards compatibility and tests.
@@ -246,4 +247,14 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(4_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
+
+	fn register_token() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `256`
+		//  Estimated: `6044`
+		// Minimum execution time: 45_000_000 picoseconds.
+		Weight::from_parts(45_000_000, 6044)
+			.saturating_add(RocksDbWeight::get().reads(5_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
 }

bridges/snowbridge/primitives/core/src/lib.rs

@@ -25,7 +25,7 @@ use frame_support::traits::Contains;
 use hex_literal::hex;
 use scale_info::TypeInfo;
 use sp_core::H256;
-use sp_io::hashing::keccak_256;
+use sp_io::hashing::{blake2_256, keccak_256};
 use sp_runtime::{traits::AccountIdConversion, RuntimeDebug};
 use sp_std::prelude::*;
 use xcm::prelude::{Junction::Parachain, Location};
@@ -163,4 +163,17 @@ impl DescribeLocation for DescribeHere {
 
 /// Creates an AgentId from a Location. An AgentId is a unique mapping to a Agent contract on
 /// Ethereum which acts as the sovereign account for the Location.
-pub type AgentIdOf = HashedDescription<H256, (DescribeHere, DescribeFamily<DescribeAllTerminal>)>;
+pub type AgentIdOf =
+	HashedDescription<AgentId, (DescribeHere, DescribeFamily<DescribeAllTerminal>)>;
+
+#[derive(Clone, Default, Eq, Debug, PartialEq, Ord, PartialOrd, Encode, Decode, TypeInfo)]
+pub struct AssetRegistrarMetadata {
+	pub name: Vec<u8>,
+	pub symbol: Vec<u8>,
+	pub decimals: u8,
+}
+
+pub type TokenId = H256;
+pub fn token_id_of(location: &Location) -> TokenId {
+	blake2_256(&location.encode()).into()
+}

bridges/snowbridge/primitives/core/src/outbound.rs

@@ -238,12 +238,32 @@ mod v1 {
 			/// The amount of tokens to transfer
 			amount: u128,
 		},
+		RegisterToken {
+			/// ID for the token
+			token_id: H256,
+			/// Name of the token
+			name: Vec<u8>,
+			/// Short symbol for the token
+			symbol: Vec<u8>,
+			/// Number of decimal places
+			decimals: u8,
+		},
+		MintToken {
+			/// ID for the token
+			token_id: H256,
+			/// The recipient of the newly minted tokens
+			recipient: H160,
+			/// The amount of tokens to mint
+			amount: u128,
+		},
 	}
 
 	impl AgentExecuteCommand {
 		fn index(&self) -> u8 {
 			match self {
 				AgentExecuteCommand::TransferToken { .. } => 0,
+				AgentExecuteCommand::RegisterToken { .. } => 1,
+				AgentExecuteCommand::MintToken { .. } => 2,
 			}
 		}
 
@@ -259,6 +279,25 @@ mod v1 {
 							Token::Uint(U256::from(*amount)),
 						])),
 					]),
+				AgentExecuteCommand::RegisterToken { token_id, name, symbol, decimals } =>
+					ethabi::encode(&[
+						Token::Uint(self.index().into()),
+						Token::Bytes(ethabi::encode(&[
+							Token::FixedBytes(token_id.as_bytes().to_owned()),
+							Token::String(name.to_owned()),
+							Token::String(symbol.to_owned()),
+							Token::Uint(U256::from(*decimals)),
+						])),
+					]),
+				AgentExecuteCommand::MintToken { token_id, recipient, amount } =>
+					ethabi::encode(&[
+						Token::Uint(self.index().into()),
+						Token::Bytes(ethabi::encode(&[
+							Token::FixedBytes(token_id.as_bytes().to_owned()),
+							Token::Address(*recipient),
+							Token::Uint(U256::from(*amount)),
+						])),
+					]),
 			}
 		}
 	}
@@ -391,6 +430,8 @@ impl GasMeter for ConstantGasMeter {
 				// * Assume dest account in ERC20 contract does not yet have a storage slot
 				// * ERC20.transferFrom possibly does other business logic besides updating balances
 				AgentExecuteCommand::TransferToken { .. } => 100_000,
+				AgentExecuteCommand::RegisterToken { .. } => 1_500_000,
+				AgentExecuteCommand::MintToken { .. } => 150_000,
 			},
 			Command::Upgrade { initializer, .. } => {
 				let initializer_max_gas = match *initializer {