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/pallet/Cargo.toml

@@ -29,6 +29,8 @@ frame-support = { git = "https://github.com/serai-dex/substrate", default-featur
 serai-primitives = { path = "../../serai/primitives", default-features = false }
 in-instructions-primitives = { path = "../primitives", default-features = false }
 
+tokens-pallet = { path = "../../tokens/pallet", default-features = false }
+
 [features]
 std = [
   "thiserror",
@@ -47,5 +49,7 @@ std = [
 
   "serai-primitives/std",
   "in-instructions-primitives/std",
+
+  "tokens-pallet/std",
 ]
 default = ["std"]

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

@@ -13,7 +13,7 @@ use sp_inherents::{InherentIdentifier, IsFatalError};
 
 use sp_runtime::RuntimeDebug;
 
-use serai_primitives::{BlockNumber, BlockHash, Coin};
+use serai_primitives::{BlockNumber, BlockHash, Coin, WithAmount, Balance};
 
 pub use in_instructions_primitives as primitives;
 use primitives::InInstruction;
@@ -24,7 +24,7 @@ pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"ininstrs";
 #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
 pub struct Batch {
   pub id: BlockHash,
-  pub instructions: Vec<InInstruction>,
+  pub instructions: Vec<WithAmount<InInstruction>>,
 }
 
 #[derive(Clone, PartialEq, Eq, Encode, Decode, TypeInfo, RuntimeDebug)]
@@ -89,10 +89,12 @@ pub mod pallet {
   use frame_support::pallet_prelude::*;
   use frame_system::pallet_prelude::*;
 
+  use tokens_pallet::{Config as TokensConfig, Pallet as Tokens};
+
   use super::*;
 
   #[pallet::config]
-  pub trait Config: frame_system::Config<BlockNumber = u32> {
+  pub trait Config: frame_system::Config<BlockNumber = u32> + TokensConfig {
     type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
   }
 
@@ -100,6 +102,7 @@ pub mod pallet {
   #[pallet::generate_deposit(fn deposit_event)]
   pub enum Event<T: Config> {
     Batch { coin: Coin, id: BlockHash },
+    Failure { coin: Coin, id: BlockHash, index: u32 },
   }
 
   #[pallet::pallet]
@@ -122,23 +125,43 @@ pub mod pallet {
     }
   }
 
+  impl<T: Config> Pallet<T> {
+    fn execute(coin: Coin, instruction: WithAmount<InInstruction>) -> Result<(), ()> {
+      match instruction.data {
+        InInstruction::Transfer(address) => {
+          Tokens::<T>::mint(address, Balance { coin, amount: instruction.amount })
+        }
+        _ => panic!("unsupported instruction"),
+      }
+      Ok(())
+    }
+  }
+
   #[pallet::call]
   impl<T: Config> Pallet<T> {
     #[pallet::call_index(0)]
-    #[pallet::weight((0, DispatchClass::Mandatory))] // TODO
-    pub fn execute(origin: OriginFor<T>, updates: Updates) -> DispatchResult {
+    #[pallet::weight((0, DispatchClass::Operational))] // TODO
+    pub fn update(origin: OriginFor<T>, mut updates: Updates) -> DispatchResult {
       ensure_none(origin)?;
       assert!(!Once::<T>::exists());
       Once::<T>::put(true);
 
-      for (coin, update) in updates.iter().enumerate() {
+      for (coin, update) in updates.iter_mut().enumerate() {
         if let Some(update) = update {
           let coin = coin_from_index(coin);
           BlockNumbers::<T>::insert(coin, update.block_number);
 
-          for batch in &update.batches {
-            // TODO: EXECUTE
+          for batch in update.batches.iter_mut() {
             Self::deposit_event(Event::Batch { coin, id: batch.id });
+            for (i, instruction) in batch.instructions.drain(..).enumerate() {
+              if Self::execute(coin, instruction).is_err() {
+                Self::deposit_event(Event::Failure {
+                  coin,
+                  id: batch.id,
+                  index: u32::try_from(i).unwrap(),
+                });
+              }
+            }
           }
         }
       }
@@ -157,7 +180,7 @@ pub mod pallet {
       data
         .get_data::<Updates>(&INHERENT_IDENTIFIER)
         .unwrap()
-        .map(|updates| Call::execute { updates })
+        .map(|updates| Call::update { updates })
     }
 
     // Assumes that only not yet handled batches are provided as inherent data
@@ -167,7 +190,7 @@ pub mod pallet {
       let expected = data.get_data::<Updates>(&INHERENT_IDENTIFIER).unwrap().unwrap();
       // Match to be exhaustive
       let updates = match call {
-        Call::execute { ref updates } => updates,
+        Call::update { ref updates } => updates,
         _ => Err(InherentError::InvalidCall)?,
       };
 

substrate/in-instructions/primitives/Cargo.toml

@@ -16,10 +16,9 @@ scale-info = { version = "2", default-features = false, features = ["derive"] }
 
 serde = { version = "1", features = ["derive"], optional = true }
 
-sp-core = { git = "https://github.com/serai-dex/substrate", default-features = false }
-
 serai-primitives = { path = "../../serai/primitives", default-features = false }
+tokens-primitives = { path = "../../tokens/primitives", default-features = false }
 
 [features]
-std = ["scale/std", "scale-info/std", "serde", "sp-core/std", "serai-primitives/std"]
+std = ["scale/std", "scale-info/std", "serde", "serai-primitives/std", "tokens-primitives/std"]
 default = ["std"]

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!(),