Add outtie pallet (#1418)

* Add outtie pallet

* compiles

* add box

* test

* add event

* add benchmarks

* add to runtime

* inline docs

* fmt

* changelog

* Apply suggestions from code review

Co-authored-by: peg <[email protected]>

* fixes

* metadata

---------

Co-authored-by: peg <[email protected]>

Author: JesseAbram

CHANGELOG.md

@@ -12,6 +12,9 @@ At the moment this project **does not** adhere to
 ### Breaking
 - In [#1387](https://github.com/entropyxyz/entropy-core/pull/1387/) the substrate version was updated, this could cause changes to the chainspec file as well requires a strategy for command line argument ```--public-addr``` and for handling ```node-key-generation```
 
+### Added
+- Add outtie pallet ([#1418](https://github.com/entropyxyz/entropy-core/pull/1418))
+
 ### Changed
 - Update substrate to polkadot stable2409 ([#1387](https://github.com/entropyxyz/entropy-core/pull/1387))
 - Remove deadlines in OCW ([#1411](https://github.com/entropyxyz/entropy-core/pull/1411))

Cargo.lock

@@ -0,0 +1,48 @@
+[package]
+name      ="pallet-outtie"
+version   ='0.4.0-rc.1'
+authors   =['Entropy Cryptography <[email protected]>']
+homepage  ='https://entropy.xyz/'
+license   ='AGPL-3.0-or-later'
+repository='https://github.com/entropyxyz/entropy-core'
+edition   ='2021'
+publish   =false
+
+[dependencies]
+codec     ={ package="parity-scale-codec", version="3.6.3", default-features=false, features=["derive"] }
+scale-info={ version="2.11", default-features=false, features=["derive"] }
+
+frame-benchmarking={ version="38.0.0", default-features=false, optional=true }
+frame-support     ={ version="38.0.0", default-features=false }
+frame-system      ={ version="38.0.0", default-features=false }
+sp-runtime        ={ version="39.0.1", default-features=false }
+sp-std            ={ version="14.0.0", default-features=false }
+pallet-session    ={ version="38.0.0", default-features=false }
+serde             ={ version="1.0.219", default-features=false }
+
+entropy-shared={ version="0.4.0-rc.1", path="../../crates/shared", features=[
+  "wasm-no-std",
+], default-features=false }
+
+[dev-dependencies]
+sp-core   ={ version="34.0.0" }
+sp-io     ={ version="38.0.0" }
+sp-staking={ version="36.0.0", default-features=false }
+
+[features]
+default=["std"]
+runtime-benchmarks=[
+  'frame-benchmarking',
+  'frame-support/runtime-benchmarks',
+  'frame-system/runtime-benchmarks',
+]
+std=[
+  "frame-support/std",
+  "frame-system/std",
+  "pallet-session/std",
+  "scale-info/std",
+  "sp-runtime/std",
+  "sp-std/std",
+  'frame-benchmarking/std',
+]
+try-runtime=["frame-support/try-runtime"]

crates/client/entropy_metadata.scale

@@ -0,0 +1,50 @@
+// Copyright (C) 2023 Entropy Cryptography Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use frame_benchmarking::v2::*;
+use frame_system::{EventRecord, RawOrigin};
+use sp_std::vec;
+
+use super::*;
+#[allow(unused)]
+use crate::Pallet as Outtie;
+
+const NULL_ARR: [u8; 32] = [0; 32];
+
+fn assert_last_event<T: Config>(generic_event: <T as Config>::RuntimeEvent) {
+    let events = frame_system::Pallet::<T>::events();
+    let system_event: <T as frame_system::Config>::RuntimeEvent = generic_event.into();
+    // compare to the last event record
+    let EventRecord { event, .. } = &events[events.len() - 1];
+    assert_eq!(event, &system_event);
+}
+
+#[benchmarks]
+mod benchmarks {
+    use super::*;
+    #[benchmark]
+    fn add_box() {
+        let caller: T::AccountId = whitelisted_caller();
+        let x25519_public_key = NULL_ARR;
+        let endpoint = vec![];
+
+        let server_info = OuttieServerInfo { x25519_public_key, endpoint };
+        #[extrinsic_call]
+        _(RawOrigin::Signed(caller.clone()), server_info.clone());
+
+        assert_last_event::<T>(Event::<T>::BoxAdded { box_account: caller, server_info }.into());
+    }
+    impl_benchmark_test_suite!(Outtie, crate::mock::new_test_ext(), crate::mock::Test);
+}

pallets/outtie/Cargo.toml

@@ -0,0 +1,119 @@
+// Copyright (C) 2023 Entropy Cryptography Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! # Outtie Pallet
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::unused_unit)]
+
+use entropy_shared::X25519PublicKey;
+use frame_support::pallet_prelude::*;
+use frame_system::pallet_prelude::*;
+#[cfg(feature = "std")]
+use serde::{Deserialize, Serialize};
+use sp_runtime::DispatchResult;
+use sp_std::vec::Vec;
+#[cfg(test)]
+mod mock;
+
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "runtime-benchmarks")]
+mod benchmarking;
+
+pub mod weights;
+
+pub use module::*;
+pub use weights::WeightInfo;
+
+#[frame_support::pallet]
+pub mod module {
+    use super::*;
+
+    #[pallet::config]
+    pub trait Config: frame_system::Config + pallet_session::Config {
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        /// The maximum length of an API box server's endpoint address, in bytes.
+        type MaxEndpointLength: Get<u32>;
+
+        /// Weight information for the extrinsics in this module.
+        type WeightInfo: WeightInfo;
+    }
+
+    /// Information about a tdx server  
+    #[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)]
+    #[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
+    pub struct OuttieServerInfo {
+        pub x25519_public_key: X25519PublicKey,
+        pub endpoint: Vec<u8>,
+        //  TODO #1421 pub provisioning_certification_key: VerifyingKey,
+    }
+
+    /// API box signing account => Server Info
+    #[pallet::storage]
+    #[pallet::getter(fn get_api_boxes)]
+    pub type ApiBoxes<T: Config> =
+        StorageMap<_, Blake2_128Concat, T::AccountId, OuttieServerInfo, OptionQuery>;
+
+    #[pallet::error]
+    pub enum Error<T> {
+        /// Endpoint is too long
+        EndpointTooLong,
+        /// Box account already exists
+        BoxAccountAlreadyExists,
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(fn deposit_event)]
+    pub enum Event<T: Config> {
+        BoxAdded { box_account: T::AccountId, server_info: OuttieServerInfo },
+    }
+
+    #[pallet::pallet]
+    #[pallet::without_storage_info]
+    pub struct Pallet<T>(_);
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        #[pallet::call_index(1)]
+        #[pallet::weight(<T as Config>::WeightInfo::add_box())]
+        pub fn add_box(
+            origin: OriginFor<T>,
+            server_info: OuttieServerInfo,
+            // TODO #1421 quote: Vec<u8>,
+        ) -> DispatchResult {
+            let box_account = ensure_signed(origin.clone())?;
+
+            ensure!(
+                server_info.endpoint.len() as u32 <= T::MaxEndpointLength::get(),
+                Error::<T>::EndpointTooLong
+            );
+
+            ensure!(
+                !ApiBoxes::<T>::contains_key(&box_account),
+                Error::<T>::BoxAccountAlreadyExists
+            );
+
+            // TODO #1421 assertion
+
+            ApiBoxes::<T>::insert(&box_account, server_info.clone());
+
+            Self::deposit_event(Event::BoxAdded { box_account, server_info });
+
+            Ok(())
+        }
+    }
+}

pallets/outtie/src/benchmarking.rs

@@ -0,0 +1,135 @@
+// Copyright (C) 2023 Entropy Cryptography Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+//! Mocks for the outtie pallet.
+
+#![cfg(test)]
+use frame_support::{
+    construct_runtime, derive_impl, parameter_types,
+    traits::{ConstU64, Everything, OneSessionHandler},
+};
+use sp_core::H256;
+use sp_runtime::{
+    testing::UintAuthorityId,
+    traits::{ConvertInto, IdentityLookup},
+    BuildStorage,
+};
+
+use super::*;
+
+pub type AccountId = u128;
+
+use crate as pallet_outtie;
+
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+impl frame_system::Config for Test {
+    type AccountData = ();
+    type AccountId = AccountId;
+    type BaseCallFilter = Everything;
+    type Block = Block;
+    type BlockHashCount = ConstU64<250>;
+    type BlockLength = ();
+    type BlockWeights = ();
+    type DbWeight = ();
+    type Hash = H256;
+    type Hashing = sp_runtime::traits::BlakeTwo256;
+    type Lookup = IdentityLookup<Self::AccountId>;
+    type MaxConsumers = frame_support::traits::ConstU32<16>;
+    type Nonce = u64;
+    type OnKilledAccount = ();
+    type OnNewAccount = ();
+    type OnSetCode = ();
+    type PalletInfo = PalletInfo;
+    type RuntimeCall = RuntimeCall;
+    type RuntimeEvent = RuntimeEvent;
+    type RuntimeOrigin = RuntimeOrigin;
+    type SS58Prefix = ();
+    type SystemWeightInfo = ();
+    type Version = ();
+}
+
+pub struct MockSessionManager;
+impl pallet_session::SessionManager<AccountId> for MockSessionManager {
+    fn end_session(_: sp_staking::SessionIndex) {}
+    fn start_session(_: sp_staking::SessionIndex) {}
+    fn new_session(_: sp_staking::SessionIndex) -> Option<Vec<AccountId>> {
+        None
+    }
+}
+
+pub struct OtherSessionHandler;
+impl OneSessionHandler<AccountId> for OtherSessionHandler {
+    type Key = UintAuthorityId;
+
+    fn on_genesis_session<'a, I: 'a>(_: I)
+    where
+        I: Iterator<Item = (&'a AccountId, Self::Key)>,
+        AccountId: 'a,
+    {
+    }
+
+    fn on_new_session<'a, I: 'a>(_: bool, _: I, _: I)
+    where
+        I: Iterator<Item = (&'a AccountId, Self::Key)>,
+        AccountId: 'a,
+    {
+    }
+
+    fn on_disabled(_validator_index: u32) {}
+}
+
+impl sp_runtime::BoundToRuntimeAppPublic for OtherSessionHandler {
+    type Public = UintAuthorityId;
+}
+
+impl pallet_session::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type ValidatorId = u128;
+    type ValidatorIdOf = ConvertInto;
+    type ShouldEndSession = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+    type NextSessionRotation = pallet_session::PeriodicSessions<ConstU64<1>, ConstU64<0>>;
+    type SessionManager = MockSessionManager;
+    type SessionHandler = (OtherSessionHandler,);
+    type Keys = UintAuthorityId;
+    type WeightInfo = ();
+}
+
+parameter_types! {
+  pub const MaxEndpointLength: u32 = 3;
+}
+
+impl Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type MaxEndpointLength = MaxEndpointLength;
+    type WeightInfo = ();
+}
+
+type Block = frame_system::mocking::MockBlock<Test>;
+
+construct_runtime!(
+  pub enum Test
+  {
+    System: frame_system,
+    Outtie: pallet_outtie,
+    Session: pallet_session,
+
+  }
+);
+
+// Build genesis storage according to the mock runtime.
+pub fn new_test_ext() -> sp_io::TestExternalities {
+    let t = frame_system::GenesisConfig::<Test>::default().build_storage().unwrap();
+    t.into()
+}