rebase to develop latest

substrate/runtime/Cargo.toml

@@ -49,6 +49,7 @@ frame-executive = { git = "https://github.com/serai-dex/substrate", default-feat
 frame-benchmarking = { git = "https://github.com/serai-dex/substrate", default-features = false, optional = true }
 
 serai-primitives = { path = "../primitives", default-features = false }
+serai-abi = { path = "../abi", default-features = false, features = ["serde"] }
 
 pallet-timestamp = { git = "https://github.com/serai-dex/substrate", default-features = false }
 pallet-authorship = { git = "https://github.com/serai-dex/substrate", default-features = false }
@@ -104,6 +105,8 @@ std = [
   "frame-executive/std",
 
   "serai-primitives/std",
+  "serai-abi/std",
+  "serai-abi/serde",
 
   "pallet-timestamp/std",
   "pallet-authorship/std",

substrate/runtime/src/abi.rs

@@ -0,0 +1,383 @@
+use core::marker::PhantomData;
+
+use scale::{Encode, Decode};
+
+use serai_abi::Call;
+
+use crate::{
+  Vec,
+  primitives::{PublicKey, SeraiAddress},
+  timestamp, coins, dex, genesis_liquidity,
+  validator_sets::{self, MembershipProof},
+  in_instructions, signals, babe, grandpa, RuntimeCall,
+};
+
+impl From<Call> for RuntimeCall {
+  fn from(call: Call) -> RuntimeCall {
+    match call {
+      Call::Timestamp(serai_abi::timestamp::Call::set { now }) => {
+        RuntimeCall::Timestamp(timestamp::Call::set { now })
+      }
+      Call::Coins(coins) => match coins {
+        serai_abi::coins::Call::transfer { to, balance } => {
+          RuntimeCall::Coins(coins::Call::transfer { to: to.into(), balance })
+        }
+        serai_abi::coins::Call::burn { balance } => {
+          RuntimeCall::Coins(coins::Call::burn { balance })
+        }
+        serai_abi::coins::Call::burn_with_instruction { instruction } => {
+          RuntimeCall::Coins(coins::Call::burn_with_instruction { instruction })
+        }
+      },
+      Call::LiquidityTokens(lt) => match lt {
+        serai_abi::liquidity_tokens::Call::transfer { to, balance } => {
+          RuntimeCall::LiquidityTokens(coins::Call::transfer { to: to.into(), balance })
+        }
+        serai_abi::liquidity_tokens::Call::burn { balance } => {
+          RuntimeCall::LiquidityTokens(coins::Call::burn { balance })
+        }
+      },
+      Call::Dex(dex) => match dex {
+        serai_abi::dex::Call::add_liquidity {
+          coin,
+          coin_desired,
+          sri_desired,
+          coin_min,
+          sri_min,
+          mint_to,
+        } => RuntimeCall::Dex(dex::Call::add_liquidity {
+          coin,
+          coin_desired,
+          sri_desired,
+          coin_min,
+          sri_min,
+          mint_to: mint_to.into(),
+        }),
+        serai_abi::dex::Call::remove_liquidity {
+          coin,
+          lp_token_burn,
+          coin_min_receive,
+          sri_min_receive,
+          withdraw_to,
+        } => RuntimeCall::Dex(dex::Call::remove_liquidity {
+          coin,
+          lp_token_burn,
+          coin_min_receive,
+          sri_min_receive,
+          withdraw_to: withdraw_to.into(),
+        }),
+        serai_abi::dex::Call::swap_exact_tokens_for_tokens {
+          path,
+          amount_in,
+          amount_out_min,
+          send_to,
+        } => RuntimeCall::Dex(dex::Call::swap_exact_tokens_for_tokens {
+          path,
+          amount_in,
+          amount_out_min,
+          send_to: send_to.into(),
+        }),
+        serai_abi::dex::Call::swap_tokens_for_exact_tokens {
+          path,
+          amount_out,
+          amount_in_max,
+          send_to,
+        } => RuntimeCall::Dex(dex::Call::swap_tokens_for_exact_tokens {
+          path,
+          amount_out,
+          amount_in_max,
+          send_to: send_to.into(),
+        }),
+      },
+      Call::GenesisLiquidity(gl) => match gl {
+        serai_abi::genesis_liquidity::Call::remove_coin_liquidity { balance } => {
+          RuntimeCall::GenesisLiquidity(genesis_liquidity::Call::remove_coin_liquidity { balance })
+        }
+        serai_abi::genesis_liquidity::Call::oraclize_values { values, signature } => {
+          RuntimeCall::GenesisLiquidity(genesis_liquidity::Call::oraclize_values {
+            values,
+            signature,
+          })
+        }
+      },
+      Call::ValidatorSets(vs) => match vs {
+        serai_abi::validator_sets::Call::set_keys {
+          network,
+          removed_participants,
+          key_pair,
+          signature,
+        } => RuntimeCall::ValidatorSets(validator_sets::Call::set_keys {
+          network,
+          removed_participants: <_>::try_from(
+            removed_participants.into_iter().map(PublicKey::from).collect::<Vec<_>>(),
+          )
+          .unwrap(),
+          key_pair,
+          signature,
+        }),
+        serai_abi::validator_sets::Call::report_slashes { network, slashes, signature } => {
+          RuntimeCall::ValidatorSets(validator_sets::Call::report_slashes {
+            network,
+            slashes: <_>::try_from(
+              slashes
+                .into_iter()
+                .map(|(addr, slash)| (PublicKey::from(addr), slash))
+                .collect::<Vec<_>>(),
+            )
+            .unwrap(),
+            signature,
+          })
+        }
+        serai_abi::validator_sets::Call::allocate { network, amount } => {
+          RuntimeCall::ValidatorSets(validator_sets::Call::allocate { network, amount })
+        }
+        serai_abi::validator_sets::Call::deallocate { network, amount } => {
+          RuntimeCall::ValidatorSets(validator_sets::Call::deallocate { network, amount })
+        }
+        serai_abi::validator_sets::Call::claim_deallocation { network, session } => {
+          RuntimeCall::ValidatorSets(validator_sets::Call::claim_deallocation { network, session })
+        }
+      },
+      Call::InInstructions(ii) => match ii {
+        serai_abi::in_instructions::Call::execute_batch { batch } => {
+          RuntimeCall::InInstructions(in_instructions::Call::execute_batch { batch })
+        }
+      },
+      Call::Signals(signals) => match signals {
+        serai_abi::signals::Call::register_retirement_signal { in_favor_of } => {
+          RuntimeCall::Signals(signals::Call::register_retirement_signal { in_favor_of })
+        }
+        serai_abi::signals::Call::revoke_retirement_signal { retirement_signal_id } => {
+          RuntimeCall::Signals(signals::Call::revoke_retirement_signal { retirement_signal_id })
+        }
+        serai_abi::signals::Call::favor { signal_id, for_network } => {
+          RuntimeCall::Signals(signals::Call::favor { signal_id, for_network })
+        }
+        serai_abi::signals::Call::revoke_favor { signal_id, for_network } => {
+          RuntimeCall::Signals(signals::Call::revoke_favor { signal_id, for_network })
+        }
+        serai_abi::signals::Call::stand_against { signal_id, for_network } => {
+          RuntimeCall::Signals(signals::Call::stand_against { signal_id, for_network })
+        }
+      },
+      Call::Babe(babe) => match babe {
+        serai_abi::babe::Call::report_equivocation(report) => {
+          RuntimeCall::Babe(babe::Call::report_equivocation {
+            // TODO: Find a better way to go from Proof<[u8; 32]> to Proof<H256>
+            equivocation_proof: <_>::decode(&mut report.equivocation_proof.encode().as_slice())
+              .unwrap(),
+            key_owner_proof: MembershipProof(report.key_owner_proof.into(), PhantomData),
+          })
+        }
+        serai_abi::babe::Call::report_equivocation_unsigned(report) => {
+          RuntimeCall::Babe(babe::Call::report_equivocation_unsigned {
+            // TODO: Find a better way to go from Proof<[u8; 32]> to Proof<H256>
+            equivocation_proof: <_>::decode(&mut report.equivocation_proof.encode().as_slice())
+              .unwrap(),
+            key_owner_proof: MembershipProof(report.key_owner_proof.into(), PhantomData),
+          })
+        }
+      },
+      Call::Grandpa(grandpa) => match grandpa {
+        serai_abi::grandpa::Call::report_equivocation(report) => {
+          RuntimeCall::Grandpa(grandpa::Call::report_equivocation {
+            // TODO: Find a better way to go from Proof<[u8; 32]> to Proof<H256>
+            equivocation_proof: <_>::decode(&mut report.equivocation_proof.encode().as_slice())
+              .unwrap(),
+            key_owner_proof: MembershipProof(report.key_owner_proof.into(), PhantomData),
+          })
+        }
+        serai_abi::grandpa::Call::report_equivocation_unsigned(report) => {
+          RuntimeCall::Grandpa(grandpa::Call::report_equivocation_unsigned {
+            // TODO: Find a better way to go from Proof<[u8; 32]> to Proof<H256>
+            equivocation_proof: <_>::decode(&mut report.equivocation_proof.encode().as_slice())
+              .unwrap(),
+            key_owner_proof: MembershipProof(report.key_owner_proof.into(), PhantomData),
+          })
+        }
+      },
+    }
+  }
+}
+
+impl TryInto<Call> for RuntimeCall {
+  type Error = ();
+
+  fn try_into(self) -> Result<Call, ()> {
+    Ok(match self {
+      RuntimeCall::Timestamp(timestamp::Call::set { now }) => {
+        Call::Timestamp(serai_abi::timestamp::Call::set { now })
+      }
+      RuntimeCall::Coins(call) => Call::Coins(match call {
+        coins::Call::transfer { to, balance } => {
+          serai_abi::coins::Call::transfer { to: to.into(), balance }
+        }
+        coins::Call::burn { balance } => serai_abi::coins::Call::burn { balance },
+        coins::Call::burn_with_instruction { instruction } => {
+          serai_abi::coins::Call::burn_with_instruction { instruction }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::LiquidityTokens(call) => Call::LiquidityTokens(match call {
+        coins::Call::transfer { to, balance } => {
+          serai_abi::liquidity_tokens::Call::transfer { to: to.into(), balance }
+        }
+        coins::Call::burn { balance } => serai_abi::liquidity_tokens::Call::burn { balance },
+        _ => Err(())?,
+      }),
+      RuntimeCall::Dex(call) => Call::Dex(match call {
+        dex::Call::add_liquidity {
+          coin,
+          coin_desired,
+          sri_desired,
+          coin_min,
+          sri_min,
+          mint_to,
+        } => serai_abi::dex::Call::add_liquidity {
+          coin,
+          coin_desired,
+          sri_desired,
+          coin_min,
+          sri_min,
+          mint_to: mint_to.into(),
+        },
+        dex::Call::remove_liquidity {
+          coin,
+          lp_token_burn,
+          coin_min_receive,
+          sri_min_receive,
+          withdraw_to,
+        } => serai_abi::dex::Call::remove_liquidity {
+          coin,
+          lp_token_burn,
+          coin_min_receive,
+          sri_min_receive,
+          withdraw_to: withdraw_to.into(),
+        },
+        dex::Call::swap_exact_tokens_for_tokens { path, amount_in, amount_out_min, send_to } => {
+          serai_abi::dex::Call::swap_exact_tokens_for_tokens {
+            path,
+            amount_in,
+            amount_out_min,
+            send_to: send_to.into(),
+          }
+        }
+        dex::Call::swap_tokens_for_exact_tokens { path, amount_out, amount_in_max, send_to } => {
+          serai_abi::dex::Call::swap_tokens_for_exact_tokens {
+            path,
+            amount_out,
+            amount_in_max,
+            send_to: send_to.into(),
+          }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::GenesisLiquidity(call) => Call::GenesisLiquidity(match call {
+        genesis_liquidity::Call::remove_coin_liquidity { balance } => {
+          serai_abi::genesis_liquidity::Call::remove_coin_liquidity { balance }
+        }
+        genesis_liquidity::Call::oraclize_values { values, signature } => {
+          serai_abi::genesis_liquidity::Call::oraclize_values { values, signature }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::ValidatorSets(call) => Call::ValidatorSets(match call {
+        validator_sets::Call::set_keys { network, removed_participants, key_pair, signature } => {
+          serai_abi::validator_sets::Call::set_keys {
+            network,
+            removed_participants: <_>::try_from(
+              removed_participants.into_iter().map(SeraiAddress::from).collect::<Vec<_>>(),
+            )
+            .unwrap(),
+            key_pair,
+            signature,
+          }
+        }
+        validator_sets::Call::report_slashes { network, slashes, signature } => {
+          serai_abi::validator_sets::Call::report_slashes {
+            network,
+            slashes: <_>::try_from(
+              slashes
+                .into_iter()
+                .map(|(addr, slash)| (SeraiAddress::from(addr), slash))
+                .collect::<Vec<_>>(),
+            )
+            .unwrap(),
+            signature,
+          }
+        }
+        validator_sets::Call::allocate { network, amount } => {
+          serai_abi::validator_sets::Call::allocate { network, amount }
+        }
+        validator_sets::Call::deallocate { network, amount } => {
+          serai_abi::validator_sets::Call::deallocate { network, amount }
+        }
+        validator_sets::Call::claim_deallocation { network, session } => {
+          serai_abi::validator_sets::Call::claim_deallocation { network, session }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::InInstructions(call) => Call::InInstructions(match call {
+        in_instructions::Call::execute_batch { batch } => {
+          serai_abi::in_instructions::Call::execute_batch { batch }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::Signals(call) => Call::Signals(match call {
+        signals::Call::register_retirement_signal { in_favor_of } => {
+          serai_abi::signals::Call::register_retirement_signal { in_favor_of }
+        }
+        signals::Call::revoke_retirement_signal { retirement_signal_id } => {
+          serai_abi::signals::Call::revoke_retirement_signal { retirement_signal_id }
+        }
+        signals::Call::favor { signal_id, for_network } => {
+          serai_abi::signals::Call::favor { signal_id, for_network }
+        }
+        signals::Call::revoke_favor { signal_id, for_network } => {
+          serai_abi::signals::Call::revoke_favor { signal_id, for_network }
+        }
+        signals::Call::stand_against { signal_id, for_network } => {
+          serai_abi::signals::Call::stand_against { signal_id, for_network }
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::Babe(call) => Call::Babe(match call {
+        babe::Call::report_equivocation { equivocation_proof, key_owner_proof } => {
+          serai_abi::babe::Call::report_equivocation(serai_abi::babe::ReportEquivocation {
+            // TODO: Find a better way to go from Proof<H256> to Proof<[u8; 32]>
+            equivocation_proof: <_>::decode(&mut equivocation_proof.encode().as_slice()).unwrap(),
+            key_owner_proof: key_owner_proof.0.into(),
+          })
+        }
+        babe::Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } => {
+          serai_abi::babe::Call::report_equivocation_unsigned(serai_abi::babe::ReportEquivocation {
+            // TODO: Find a better way to go from Proof<H256> to Proof<[u8; 32]>
+            equivocation_proof: <_>::decode(&mut equivocation_proof.encode().as_slice()).unwrap(),
+            key_owner_proof: key_owner_proof.0.into(),
+          })
+        }
+        _ => Err(())?,
+      }),
+      RuntimeCall::Grandpa(call) => Call::Grandpa(match call {
+        grandpa::Call::report_equivocation { equivocation_proof, key_owner_proof } => {
+          serai_abi::grandpa::Call::report_equivocation(serai_abi::grandpa::ReportEquivocation {
+            // TODO: Find a better way to go from Proof<H256> to Proof<[u8; 32]>
+            equivocation_proof: <_>::decode(&mut equivocation_proof.encode().as_slice()).unwrap(),
+            key_owner_proof: key_owner_proof.0.into(),
+          })
+        }
+        grandpa::Call::report_equivocation_unsigned { equivocation_proof, key_owner_proof } => {
+          serai_abi::grandpa::Call::report_equivocation_unsigned(
+            serai_abi::grandpa::ReportEquivocation {
+              // TODO: Find a better way to go from Proof<H256> to Proof<[u8; 32]>
+              equivocation_proof: <_>::decode(&mut equivocation_proof.encode().as_slice()).unwrap(),
+              key_owner_proof: key_owner_proof.0.into(),
+            },
+          )
+        }
+        _ => Err(())?,
+      }),
+      _ => Err(())?,
+    })
+  }
+}

substrate/runtime/src/lib.rs

@@ -49,7 +49,11 @@ use sp_runtime::{
   BoundedVec, Perbill, ApplyExtrinsicResult,
 };
 
-use primitives::{NetworkId, PublicKey, AccountLookup, SubstrateAmount, Coin, NETWORKS};
+#[allow(unused_imports)]
+use primitives::{
+  NetworkId, PublicKey, AccountLookup, SubstrateAmount, Coin, NETWORKS, MEDIAN_PRICE_WINDOW_LENGTH,
+  HOURS, DAYS, MINUTES, TARGET_BLOCK_TIME, BLOCK_SIZE,
+};
 
 use support::{
   traits::{ConstU8, ConstU16, ConstU32, ConstU64, Contains},
@@ -66,6 +70,8 @@ use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId;
 use babe::AuthorityId as BabeId;
 use grandpa::AuthorityId as GrandpaId;
 
+mod abi;
+
 /// Nonce of a transaction in the chain, for a given account.
 pub type Nonce = u32;
 
@@ -83,7 +89,7 @@ pub type SignedExtra = (
   transaction_payment::ChargeTransactionPayment<Runtime>,
 );
 
-pub type Transaction = serai_primitives::Transaction<RuntimeCall, SignedExtra>;
+pub type Transaction = serai_abi::tx::Transaction<RuntimeCall, SignedExtra>;
 pub type Block = generic::Block<Header, Transaction>;
 pub type BlockId = generic::BlockId<Block>;
 
@@ -114,28 +120,7 @@ pub fn native_version() -> NativeVersion {
   NativeVersion { runtime_version: VERSION, can_author_with: Default::default() }
 }
 
-// 1 MB
-pub const BLOCK_SIZE: u32 = 1024 * 1024;
-// 6 seconds
-pub const TARGET_BLOCK_TIME: u64 = 6;
-
-/// Measured in blocks.
-pub const MINUTES: BlockNumber = 60 / TARGET_BLOCK_TIME;
-pub const HOURS: BlockNumber = MINUTES * 60;
-pub const DAYS: BlockNumber = HOURS * 24;
-
 pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4);
-
-/// This needs to be long enough for arbitrage to occur and make holding any fake price up
-/// sufficiently unrealistic.
-#[allow(clippy::cast_possible_truncation)]
-pub const ARBITRAGE_TIME: u16 = (2 * HOURS) as u16;
-
-/// Since we use the median price, double the window length.
-///
-/// We additionally +1 so there is a true median.
-pub const MEDIAN_PRICE_WINDOW_LENGTH: u16 = (2 * ARBITRAGE_TIME) + 1;
-
 pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration =
   sp_consensus_babe::BabeEpochConfiguration {
     c: PRIMARY_PROBABILITY,
@@ -163,38 +148,9 @@ parameter_types! {
 pub struct CallFilter;
 impl Contains<RuntimeCall> for CallFilter {
   fn contains(call: &RuntimeCall) -> bool {
-    match call {
-      RuntimeCall::Timestamp(call) => match call {
-        timestamp::Call::set { .. } => true,
-        timestamp::Call::__Ignore(_, _) => false,
-      },
-
-      // All of these pallets are our own, and all of their written calls are intended to be called
-      RuntimeCall::Coins(call) => !matches!(call, coins::Call::__Ignore(_, _)),
-      RuntimeCall::LiquidityTokens(call) => match call {
-        coins::Call::transfer { .. } | coins::Call::burn { .. } => true,
-        coins::Call::burn_with_instruction { .. } | coins::Call::__Ignore(_, _) => false,
-      },
-      RuntimeCall::Dex(call) => !matches!(call, dex::Call::__Ignore(_, _)),
-      RuntimeCall::ValidatorSets(call) => !matches!(call, validator_sets::Call::__Ignore(_, _)),
-      RuntimeCall::GenesisLiquidity(call) => {
-        !matches!(call, genesis_liquidity::Call::__Ignore(_, _))
-      }
-      RuntimeCall::InInstructions(call) => !matches!(call, in_instructions::Call::__Ignore(_, _)),
-      RuntimeCall::Signals(call) => !matches!(call, signals::Call::__Ignore(_, _)),
-
-      RuntimeCall::Babe(call) => match call {
-        babe::Call::report_equivocation { .. } |
-        babe::Call::report_equivocation_unsigned { .. } => true,
-        babe::Call::plan_config_change { .. } | babe::Call::__Ignore(_, _) => false,
-      },
-
-      RuntimeCall::Grandpa(call) => match call {
-        grandpa::Call::report_equivocation { .. } |
-        grandpa::Call::report_equivocation_unsigned { .. } => true,
-        grandpa::Call::note_stalled { .. } | grandpa::Call::__Ignore(_, _) => false,
-      },
-    }
+    // If the call is defined in our ABI, it's allowed
+    let call: Result<serai_abi::Call, ()> = call.clone().try_into();
+    call.is_ok()
   }
 }
 
@@ -375,6 +331,7 @@ construct_runtime!(
     Coins: coins,
     LiquidityTokens: coins::<Instance1>::{Pallet, Call, Storage, Event<T>},
     Dex: dex,
+    GenesisLiquidity: genesis_liquidity,
 
     ValidatorSets: validator_sets,
     GenesisLiquidity: genesis_liquidity,