Tokens pallet (#243)

* Use Monero-compatible additional TX keys

This still sends a fingerprinting flare up if you send to a subaddress which
needs to be fixed. Despite that, Monero no should no longer fail to scan TXs
from monero-serai regarding additional keys.

Previously it failed becuase we supplied one key as THE key, and n-1 as
additional. Monero expects n for additional.

This does correctly select when to use THE key versus when to use the additional
key when sending. That removes the ability for recipients to fingerprint
monero-serai by receiving to a standard address yet needing to use an additional
key.

* Add tokens_primitives

Moves OutInstruction from in-instructions.

Turns Destination into OutInstruction.

* Correct in-instructions DispatchClass

* Add initial tokens pallet

* Don't allow pallet addresses to equal identity

* Add support for InInstruction::transfer

Requires a cargo update due to modifications made to serai-dex/substrate.

Successfully mints a token to a SeraiAddress.

* Bind InInstructions to an amount

* Add a call filter to the runtime

Prevents worrying about calls to the assets pallet/generally tightens things
up.

* Restore Destination

It was meged into OutInstruction, yet it didn't make sense for OutInstruction
to contain a SeraiAddress.

Also deletes the excessively dated Scenarios doc.

* Split PublicKey/SeraiAddress

Lets us define a custom Display/ToString for SeraiAddress.

Also resolves an oddity where PublicKey would be encoded as String, not
[u8; 32].

* Test burning tokens/retrieving OutInstructions

Modularizes processor_coinUpdates into a shared testing utility.

* Misc lint

* Don't use PolkadotExtrinsicParams

substrate/in-instructions/primitives/src/incoming.rs

@@ -1,38 +0,0 @@
-use scale::{Encode, Decode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::{Serialize, Deserialize};
-
-use sp_core::{ConstU32, bounded::BoundedVec};
-
-use serai_primitives::SeraiAddress;
-
-use crate::{MAX_DATA_LEN, ExternalAddress};
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub enum Application {
-  DEX,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct ApplicationCall {
-  application: Application,
-  data: BoundedVec<u8, ConstU32<{ MAX_DATA_LEN }>>,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub enum InInstruction {
-  Transfer(SeraiAddress),
-  Call(ApplicationCall),
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct RefundableInInstruction {
-  pub origin: Option<ExternalAddress>,
-  pub instruction: InInstruction,
-}

substrate/in-instructions/primitives/src/lib.rs

@@ -8,40 +8,34 @@ use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
 
-use sp_core::{ConstU32, bounded::BoundedVec};
-
-// Monero, our current longest address candidate, has a longest address of featured with payment ID
-// 1 (enum) + 1 (flags) + 64 (two keys) + 8 (payment ID) = 74
-pub const MAX_ADDRESS_LEN: u32 = 74;
-// Should be enough for a Uniswap v3 call
-pub const MAX_DATA_LEN: u32 = 512;
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct ExternalAddress(BoundedVec<u8, ConstU32<{ MAX_ADDRESS_LEN }>>);
-impl ExternalAddress {
-  #[cfg(feature = "std")]
-  pub fn new(address: Vec<u8>) -> Result<ExternalAddress, &'static str> {
-    Ok(ExternalAddress(address.try_into().map_err(|_| "address length exceeds {MAX_ADDRESS_LEN}")?))
-  }
-
-  pub fn address(&self) -> &[u8] {
-    self.0.as_ref()
-  }
-
-  #[cfg(feature = "std")]
-  pub fn consume(self) -> Vec<u8> {
-    self.0.into_inner()
-  }
-}
-
-// Not "in" as "in" is a keyword
-mod incoming;
-pub use incoming::*;
-
-// Not "out" to match in
-mod outgoing;
-pub use outgoing::*;
+use serai_primitives::{SeraiAddress, ExternalAddress, Data};
 
 mod shorthand;
 pub use shorthand::*;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum Application {
+  DEX,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct ApplicationCall {
+  application: Application,
+  data: Data,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub enum InInstruction {
+  Transfer(SeraiAddress),
+  Call(ApplicationCall),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+pub struct RefundableInInstruction {
+  pub origin: Option<ExternalAddress>,
+  pub instruction: InInstruction,
+}

substrate/in-instructions/primitives/src/outgoing.rs

@@ -1,25 +0,0 @@
-use scale::{Encode, Decode, MaxEncodedLen};
-use scale_info::TypeInfo;
-
-#[cfg(feature = "std")]
-use serde::{Serialize, Deserialize};
-
-use sp_core::{ConstU32, bounded::BoundedVec};
-
-use serai_primitives::SeraiAddress;
-
-use crate::{MAX_DATA_LEN, ExternalAddress};
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub enum Destination {
-  Native(SeraiAddress),
-  External(ExternalAddress),
-}
-
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
-pub struct OutInstruction {
-  destination: Destination,
-  data: Option<BoundedVec<u8, ConstU32<{ MAX_DATA_LEN }>>>,
-}

substrate/in-instructions/primitives/src/shorthand.rs

@@ -4,16 +4,18 @@ use scale_info::TypeInfo;
 #[cfg(feature = "std")]
 use serde::{Serialize, Deserialize};
 
-use sp_core::{ConstU32, bounded::BoundedVec};
+use serai_primitives::{Coin, Amount, SeraiAddress, ExternalAddress, Data};
 
-use serai_primitives::{SeraiAddress, Coin, Amount};
+use tokens_primitives::OutInstruction;
 
-use crate::{MAX_DATA_LEN, ExternalAddress, RefundableInInstruction, InInstruction, OutInstruction};
+use crate::RefundableInInstruction;
+#[cfg(feature = "std")]
+use crate::InInstruction;
 
 #[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 pub enum Shorthand {
-  Raw(BoundedVec<u8, ConstU32<{ MAX_DATA_LEN }>>),
+  Raw(Data),
   Swap {
     origin: Option<ExternalAddress>,
     coin: Coin,
@@ -29,9 +31,10 @@ pub enum Shorthand {
 }
 
 impl Shorthand {
+  #[cfg(feature = "std")]
   pub fn transfer(origin: Option<ExternalAddress>, address: SeraiAddress) -> Option<Self> {
     Some(Self::Raw(
-      BoundedVec::try_from(
+      Data::new(
         (RefundableInInstruction { origin, instruction: InInstruction::Transfer(address) })
           .encode(),
       )
@@ -45,7 +48,7 @@ impl TryFrom<Shorthand> for RefundableInInstruction {
   fn try_from(shorthand: Shorthand) -> Result<RefundableInInstruction, &'static str> {
     Ok(match shorthand {
       Shorthand::Raw(raw) => {
-        RefundableInInstruction::decode(&mut raw.as_ref()).map_err(|_| "invalid raw instruction")?
+        RefundableInInstruction::decode(&mut raw.data()).map_err(|_| "invalid raw instruction")?
       }
       Shorthand::Swap { .. } => todo!(),
       Shorthand::AddLiquidity { .. } => todo!(),