From 17a264fdca1ca57eb34e9fc7b599584f60d1339a Mon Sep 17 00:00:00 2001 From: AlphaGamingArcade Date: Mon, 2 Dec 2024 11:38:17 +0800 Subject: [PATCH] message upgrade --- Cargo.lock | 142 +++- Cargo.toml | 13 + node/src/chain_spec.rs | 6 + node/src/command.rs | 1 + pallets/access-segregator/Cargo.toml | 48 ++ pallets/access-segregator/src/benchmarking.rs | 29 + pallets/access-segregator/src/lib.rs | 360 ++++++++++ pallets/access-segregator/src/mock.rs | 124 ++++ pallets/access-segregator/src/weights.rs | 61 ++ pallets/bridge/Cargo.toml | 55 ++ pallets/bridge/src/benchmarking.rs | 35 + pallets/bridge/src/lib.rs | 657 ++++++++++++++++++ pallets/bridge/src/mock.rs | 0 pallets/bridge/src/tests.rs | 2 + pallets/bridge/src/weights.rs | 184 +++++ primitives/aga/Cargo.toml | 31 + primitives/aga/src/lib.rs | 32 + resources/aga-chain-spec-raw.json | 45 ++ resources/aga-chain-spec.json | 50 ++ runtime/Cargo.toml | 19 +- .../rustc-ice-2024-11-29T08_54_19-27816.txt | 57 ++ runtime/src/apis.rs | 42 +- runtime/src/configs/mod.rs | 230 +++++- runtime/src/lib.rs | 40 +- 24 files changed, 2245 insertions(+), 18 deletions(-) create mode 100644 pallets/access-segregator/Cargo.toml create mode 100644 pallets/access-segregator/src/benchmarking.rs create mode 100644 pallets/access-segregator/src/lib.rs create mode 100644 pallets/access-segregator/src/mock.rs create mode 100644 pallets/access-segregator/src/weights.rs create mode 100644 pallets/bridge/Cargo.toml create mode 100644 pallets/bridge/src/benchmarking.rs create mode 100644 pallets/bridge/src/lib.rs create mode 100644 pallets/bridge/src/mock.rs create mode 100644 pallets/bridge/src/tests.rs create mode 100644 pallets/bridge/src/weights.rs create mode 100644 primitives/aga/Cargo.toml create mode 100644 primitives/aga/src/lib.rs create mode 100644 resources/aga-chain-spec-raw.json create mode 100644 resources/aga-chain-spec.json create mode 100644 runtime/rustc-ice-2024-11-29T08_54_19-27816.txt diff --git a/Cargo.lock b/Cargo.lock index 6fb6065..cba8d11 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -71,6 +71,47 @@ dependencies = [ "subtle 2.6.1", ] +[[package]] +name = "aga-access-segregator" +version = "0.1.0" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", +] + +[[package]] +name = "aga-bridge" +version = "0.1.0" +dependencies = [ + "aga-access-segregator", + "aga-primitives", + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "primitive-types 0.13.1", + "scale-info", + "sp-api", + "sp-core", + "sp-io", + "sp-runtime", +] + +[[package]] +name = "aga-primitives" +version = "0.1.0" +dependencies = [ + "parity-scale-codec", + "scale-info", + "sp-core", +] + [[package]] name = "ahash" version = "0.8.11" @@ -3269,6 +3310,26 @@ dependencies = [ "parity-scale-codec", ] +[[package]] +name = "impl-codec" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b67aa010c1e3da95bf151bd8b4c059b2ed7e75387cdb969b4f8f2723a43f9941" +dependencies = [ + "parity-scale-codec", +] + +[[package]] +name = "impl-num-traits" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "803d15461ab0dcc56706adf266158acbc44ccf719bf7d0af30705f58b90a4b8c" +dependencies = [ + "integer-sqrt", + "num-traits", + "uint 0.10.0", +] + [[package]] name = "impl-serde" version = "0.4.0" @@ -3814,7 +3875,7 @@ dependencies = [ "sha2 0.10.8", "smallvec", "thiserror", - "uint", + "uint 0.9.5", "unsigned-varint 0.7.2", "void", ] @@ -4271,7 +4332,7 @@ dependencies = [ "tokio-util", "tracing", "trust-dns-resolver", - "uint", + "uint 0.9.5", "unsigned-varint 0.8.0", "url", "webpki", @@ -5108,6 +5169,42 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39" +[[package]] +name = "pallet-asset-conversion" +version = "20.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33f0078659ae95efe6a1bf138ab5250bc41ab98f22ff3651d0208684f08ae797" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-arithmetic", + "sp-core", + "sp-io", + "sp-runtime", +] + +[[package]] +name = "pallet-assets" +version = "40.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f45f4eb6027fc34c4650e0ed6a7e57ed3335cc364be74b4531f714237676bcee" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-runtime", +] + [[package]] name = "pallet-aura" version = "37.0.0" @@ -5783,10 +5880,23 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2" dependencies = [ "fixed-hash", - "impl-codec", + "impl-codec 0.6.0", "impl-serde", "scale-info", - "uint", + "uint 0.9.5", +] + +[[package]] +name = "primitive-types" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d15600a7d856470b7d278b3fe0e311fe28c2526348549f8ef2ff7db3299c87f5" +dependencies = [ + "fixed-hash", + "impl-codec 0.7.0", + "impl-num-traits", + "scale-info", + "uint 0.10.0", ] [[package]] @@ -8210,6 +8320,8 @@ dependencies = [ name = "solochain-template-runtime" version = "0.1.0" dependencies = [ + "aga-access-segregator", + "aga-bridge", "frame-benchmarking", "frame-executive", "frame-metadata-hash-extension", @@ -8218,9 +8330,13 @@ dependencies = [ "frame-system-benchmarking", "frame-system-rpc-runtime-api", "frame-try-runtime", + "pallet-asset-conversion", + "pallet-assets", "pallet-aura", + "pallet-authorship", "pallet-balances", "pallet-grandpa", + "pallet-session", "pallet-sudo", "pallet-template", "pallet-timestamp", @@ -8238,6 +8354,8 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", + "sp-staking", + "sp-std", "sp-storage", "sp-transaction-pool", "sp-version", @@ -8431,7 +8549,7 @@ dependencies = [ "parity-scale-codec", "parking_lot 0.12.3", "paste", - "primitive-types", + "primitive-types 0.12.2", "rand", "scale-info", "schnorrkel", @@ -8689,7 +8807,7 @@ dependencies = [ "impl-trait-for-tuples", "parity-scale-codec", "polkavm-derive", - "primitive-types", + "primitive-types 0.12.2", "sp-externalities", "sp-runtime-interface-proc-macro", "sp-std", @@ -9824,6 +9942,18 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "uint" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "909988d098b2f738727b161a106cfc7cab00c539c2687a8836f8e565976fb53e" +dependencies = [ + "byteorder", + "crunchy", + "hex", + "static_assertions", +] + [[package]] name = "unicode-bidi" version = "0.3.17" diff --git a/Cargo.toml b/Cargo.toml index b4d6818..8a8370a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,10 +10,20 @@ members = [ "node", "pallets/template", "runtime", + "pallets/access-segregator", + "pallets/bridge", + "primitives/aga", ] resolver = "2" [workspace.dependencies] +primitive-types = { version = "0.13.1", default-features = false, features = ["codec", "scale-info", "num-traits"]} +aga-access-segregator = { path = "./pallets/access-segregator", default-features = false } +aga-bridge = { path = "./pallets/bridge", default-features = false } +aga-primitives = { path = "./primitives/aga", default-features = false } +pallet-authorship = { version = "38.0.0", default-features = false } +pallet-asset-conversion = { version = "20.0.0", default-features = false } +pallet-assets = { version = "40.0.0", default-features = false } solochain-template-runtime = { path = "./runtime", default-features = false } pallet-template = { path = "./pallets/template", default-features = false } clap = { version = "4.5.10" } @@ -64,6 +74,8 @@ pallet-grandpa = { version = "38.0.0", default-features = false } pallet-sudo = { version = "38.0.0", default-features = false } pallet-timestamp = { version = "37.0.0", default-features = false } pallet-transaction-payment-rpc-runtime-api = { version = "38.0.0", default-features = false } +sp-staking = { version = "36.0.0", default-features = false } +pallet-session = { version = "38.0.0", default-features = false } scale-info = { version = "2.11.1", default-features = false } sp-genesis-builder = { version = "0.15.1", default-features = false } sp-offchain = { version = "34.0.0", default-features = false } @@ -72,3 +84,4 @@ sp-storage = { version = "21.0.0", default-features = false } sp-transaction-pool = { version = "34.0.0", default-features = false } sp-version = { version = "37.0.0", default-features = false } substrate-wasm-builder = { version = "24.0.1", default-features = false } +sp-std = { version = "14.0.0", default-features = false } diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index 651025e..4ae338b 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -115,3 +115,9 @@ fn testnet_genesis( }, }) } + + +// LIVE CONFIG +pub fn aga_config() -> Result { + ChainSpec::from_json_bytes(&include_bytes!("../../resources/aga-chain-spec-raw.json")[..]) +} diff --git a/node/src/command.rs b/node/src/command.rs index 624ace1..a387c13 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -39,6 +39,7 @@ impl SubstrateCli for Cli { Ok(match id { "dev" => Box::new(chain_spec::development_config()?), "" | "local" => Box::new(chain_spec::local_testnet_config()?), + "aga" => Box::new(chain_spec::aga_config()?), path => Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?), }) diff --git a/pallets/access-segregator/Cargo.toml b/pallets/access-segregator/Cargo.toml new file mode 100644 index 0000000..71657de --- /dev/null +++ b/pallets/access-segregator/Cargo.toml @@ -0,0 +1,48 @@ +[package] +name = "aga-access-segregator" +description = "FRAME pallet template for defining custom runtime logic." +version = "0.1.0" +license = "Unlicense" +authors.workspace = true +homepage.workspace = true +repository.workspace = true +edition.workspace = true +publish = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { features = [ + "derive", +], workspace = true } +scale-info = { features = [ + "derive", +], workspace = true } +frame-benchmarking = { optional = true, workspace = true } +frame-support.workspace = true +frame-system.workspace = true + +[dev-dependencies] +sp-core = { default-features = true, workspace = true } +sp-io = { default-features = true, workspace = true } +sp-runtime = { default-features = true, workspace = true } + +[features] +default = ["std"] +std = [ + "codec/std", + "frame-benchmarking?/std", + "frame-support/std", + "frame-system/std", + "scale-info/std", +] +runtime-benchmarks = [ + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", +] +try-runtime = [ + "frame-support/try-runtime", + "frame-system/try-runtime", +] diff --git a/pallets/access-segregator/src/benchmarking.rs b/pallets/access-segregator/src/benchmarking.rs new file mode 100644 index 0000000..2a2b4c2 --- /dev/null +++ b/pallets/access-segregator/src/benchmarking.rs @@ -0,0 +1,29 @@ +// The Licensed Work is (c) 2022 Sygma +// SPDX-License-Identifier: LGPL-3.0-only + +//! Sygma access-segreator pallet benchmarking. + +#![cfg(feature = "runtime-benchmarks")] +use super::*; +use frame_benchmarking::v2::*; +use frame_system::RawOrigin as SystemOrigin; + +use sp_std::vec; + +#[benchmarks] +mod benchmarks { + use super::*; + + #[benchmark] + fn grant_access() { + let caller: ::AccountId = whitelisted_caller(); + + #[extrinsic_call] + grant_access(SystemOrigin::Root, 100, b"grant_access".to_vec(), caller.clone()); + + assert_eq!( + ExtrinsicAccess::::get(&(100, b"grant_access".to_vec())), + Some(caller).into(), + ); + } +} diff --git a/pallets/access-segregator/src/lib.rs b/pallets/access-segregator/src/lib.rs new file mode 100644 index 0000000..dbdac16 --- /dev/null +++ b/pallets/access-segregator/src/lib.rs @@ -0,0 +1,360 @@ +// The Licensed Work is (c) 2022 Sygma +// SPDX-License-Identifier: LGPL-3.0-only + +#![cfg_attr(not(feature = "std"), no_std)] + +pub use self::pallet::*; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; +pub use weights::*; + +#[cfg(test)] +mod mock; + +#[allow(unused_variables)] +#[allow(clippy::large_enum_variant)] +#[frame_support::pallet] +pub mod pallet { + use frame_support::{dispatch::DispatchResult, pallet_prelude::*, traits::StorageVersion}; + use frame_system::pallet_prelude::*; + use scale_info::prelude::vec::Vec; + + const STORAGE_VERSION: StorageVersion = StorageVersion::new(0); + + /// Mapping signature of extrinsic to account has access + /// (pallet_index, extrinsic_name) => account + #[pallet::storage] + #[pallet::getter(fn extrinsic_access)] + #[pallet::unbounded] + pub type ExtrinsicAccess = StorageMap<_, Twox64Concat, (u8, Vec), T::AccountId>; + + pub trait WeightInfo { + fn grant_access() -> Weight; + fn revoke_access() -> Weight; + } + + #[pallet::pallet] + #[pallet::storage_version(STORAGE_VERSION)] + pub struct Pallet(_); + + #[pallet::config] + pub trait Config: frame_system::Config { + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + /// Origin used to administer the pallet + type BridgeCommitteeOrigin: EnsureOrigin; + + /// Current pallet index defined in runtime + type PalletIndex: Get; + + /// Registered extrinsics + /// List of (pallet_index, extrinsic_name) + type Extrinsics: Get)>>; + + /// Type representing the weight of this pallet + type WeightInfo: WeightInfo; + } + + #[pallet::event] + #[pallet::generate_deposit(pub (super) fn deposit_event)] + pub enum Event { + /// Extrinsic access grant to someone + /// args: [pallet_index, extrinsic_name, who] + AccessGranted { pallet_index: u8, extrinsic_name: Vec, who: T::AccountId }, + /// Extrinsic access revoke access + /// args: [pallet_index, extrinsic_name, who] + AccessRevoked { pallet_index: u8, extrinsic_name: Vec, who: T::AccountId }, + } + + #[pallet::error] + pub enum Error { + /// Function unimplemented + Unimplemented, + /// Failed to grant extrinsic access permission to an account + GrantAccessFailed, + /// Access already exists + AlreadyGranted, + /// Revoking access failed + RevokeAccessFailed, + //// An Account has no access to the extrinsic + AccountNoAccess + } + + #[pallet::call] + impl Pallet { + /// Grants access to an account for a extrinsic. + #[pallet::call_index(0)] + #[pallet::weight(T::WeightInfo::grant_access())] + pub fn grant_access( + origin: OriginFor, + pallet_index: u8, + extrinsic_name: Vec, + who: T::AccountId, + ) -> DispatchResult { + // Ensure bridge committee or the account that has permission to grant access to an + // extrinsic + ensure!( + Self::has_access(T::PalletIndex::get(), b"grant_access".to_vec(), origin), + Error::::GrantAccessFailed + ); + + // Check if the account already have access + if let Some(existing_who) = ExtrinsicAccess::::get((pallet_index, extrinsic_name.clone())) { + if existing_who == who { + return Err(Error::::AlreadyGranted.into()); + } + } + + // Apply access + ExtrinsicAccess::::insert((pallet_index, extrinsic_name.clone()), &who); + + // Emit AccessGranted event + Self::deposit_event(Event::AccessGranted { pallet_index, extrinsic_name, who }); + Ok(()) + } + + /// Revokes access for an account to an extrinsic. + #[pallet::call_index(1)] + #[pallet::weight(T::WeightInfo::revoke_access())] + pub fn revoke_access( + origin: OriginFor, + pallet_index: u8, + extrinsic_name: Vec, + ) -> DispatchResult { + // Ensure bridge committee or the account that has permission to revoke access to an extrinsic + ensure!( + Self::has_access(T::PalletIndex::get(), b"revoke_access".to_vec(), origin), + Error::::RevokeAccessFailed + ); + + // Check if the access exists + let existing_who = ExtrinsicAccess::::get((pallet_index, extrinsic_name.clone())) + .ok_or(Error::::AccountNoAccess)?; + + // Remove access + ExtrinsicAccess::::remove((pallet_index, extrinsic_name.clone())); + + // Emit AccessRevoked event + Self::deposit_event(Event::AccessRevoked { pallet_index, extrinsic_name, who: existing_who }); + Ok(()) + } + } + + impl Pallet { + pub fn has_access(pallet_index: u8, extrinsic_name: Vec, origin: OriginFor) -> bool { + if T::BridgeCommitteeOrigin::ensure_origin(origin.clone()).is_ok() { + return true; + } + + let caller = match ensure_signed(origin) { + Ok(caller) => caller, + _ => return false, + }; + + Self::has_registered(pallet_index, extrinsic_name.clone()) + && ExtrinsicAccess::::get((pallet_index, extrinsic_name)) + .map_or(false, |who| who == caller) + } + + pub fn has_registered(pallet_index: u8, extrinsic_name: Vec) -> bool { + T::Extrinsics::get() + .iter() + .any(|e| e == &(pallet_index, extrinsic_name.clone())) + } + } + + #[cfg(test)] + mod test { + use crate as aga_access_segregator; + use crate::{ + mock::{ + assert_events, new_test_ext, AccessSegregator, PalletIndex, RuntimeEvent as Event, + RuntimeOrigin as Origin, Test, ALICE, BOB, CHARLIE, + }, + Event as AccessSegregatorEvent, + }; + use frame_support::{assert_noop, assert_ok}; + + #[test] + fn should_work() { + new_test_ext().execute_with(|| { + assert_noop!( + AccessSegregator::grant_access( + Some(ALICE).into(), + PalletIndex::get(), + b"grant_access".to_vec(), + BOB + ), + aga_access_segregator::Error::::GrantAccessFailed + ); + + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(ALICE).into() + )); + assert_ok!(AccessSegregator::grant_access( + Origin::root(), + PalletIndex::get(), + b"grant_access".to_vec(), + ALICE + )); + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(ALICE).into() + )); + + // ALICE grants access permission to BOB for an extrinsic (PalletIndex::get(), + // "unknown_extrinsic") + assert_ok!(AccessSegregator::grant_access( + Some(ALICE).into(), + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + BOB + )); + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Some(ALICE).into() + )); + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Some(BOB).into() + )); + + assert_events(vec![ + Event::AccessSegregator(AccessSegregatorEvent::AccessGranted { + pallet_index: PalletIndex::get(), + extrinsic_name: b"grant_access".to_vec(), + who: ALICE, + }), + Event::AccessSegregator(AccessSegregatorEvent::AccessGranted { + pallet_index: PalletIndex::get(), + extrinsic_name: b"unknown_extrinsic".to_vec(), + who: BOB, + }), + ]); + }) + } + + #[test] + fn pure_grant_access_test() { + new_test_ext().execute_with(|| { + // ALICE grants BOB access, should fail because ALICE does not have access to + // extrinsic 'grant_access' yet, should get GrantAccessFailed error + assert_noop!( + AccessSegregator::grant_access( + Some(ALICE).into(), + PalletIndex::get(), + b"grant_access".to_vec(), + BOB + ), + aga_access_segregator::Error::::GrantAccessFailed + ); + // neither ALICE nor BOB should have the access + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(ALICE).into() + )); + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(BOB).into() + )); + + // Root origin grants access to BOB of the access extrinsic `grant_access`, not + // ALICE so that BOB is able to grant other accounts just like Root origin + assert_ok!(AccessSegregator::grant_access( + Origin::root(), + PalletIndex::get(), + b"grant_access".to_vec(), + BOB + )); + // BOB has access, but ALICE does not + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(BOB).into() + )); + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Origin::root() + )); + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(ALICE).into() + )); + + // BOB grants access to CHARLIE of access to extrinsic `unknown_extrinsic`, should + // work check if CHARLIE already has access to extrinsic unknown_extrinsic + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Some(CHARLIE).into() + )); + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Origin::root() + )); + assert_ok!(AccessSegregator::grant_access( + Some(BOB).into(), + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + CHARLIE + )); + + // BOB has access of extrinsic `grant_access` + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(BOB).into() + )); + + // CHARLIE should not have access to any extrinsic other then extrinsic + // `unknown_extrinsic` + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"grant_access".to_vec(), + Some(CHARLIE).into() + )); + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic2".to_vec(), + Some(CHARLIE).into() + )); + assert!(AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Some(CHARLIE).into() + )); + + // AlICE does not have access to extrinsic `unknown_extrinsic` at this moment + assert!(!AccessSegregator::has_access( + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + Some(ALICE).into() + )); + // Since CHARLIE has the access to extrinsic `unknown_extrinsic`, not extrinsic + // `grant_access`, CHARLIE tries to grant access to ALICE of extrinsic + // `unknown_extrinsic`, should not work + assert_noop!( + AccessSegregator::grant_access( + Some(CHARLIE).into(), + PalletIndex::get(), + b"unknown_extrinsic".to_vec(), + ALICE + ), + aga_access_segregator::Error::::GrantAccessFailed + ); + }) + } + } +} diff --git a/pallets/access-segregator/src/mock.rs b/pallets/access-segregator/src/mock.rs new file mode 100644 index 0000000..9ba4a15 --- /dev/null +++ b/pallets/access-segregator/src/mock.rs @@ -0,0 +1,124 @@ +// The Licensed Work is (c) 2022 Sygma +// SPDX-License-Identifier: LGPL-3.0-only + +use frame_support::{ + pallet_prelude::ConstU32, + parameter_types, + sp_runtime::{ + testing::H256, + traits::{BlakeTwo256, IdentityLookup}, + AccountId32, BuildStorage, Perbill, + }, +}; +use frame_system::{self as system, EnsureRoot}; + +use crate as aga_access_segregator; + +type Block = frame_system::mocking::MockBlock; + +pub(crate) type Balance = u128; + +pub const ALICE: AccountId32 = AccountId32::new([0u8; 32]); +pub const BOB: AccountId32 = AccountId32::new([1u8; 32]); +pub const CHARLIE: AccountId32 = AccountId32::new([2u8; 32]); + +frame_support::construct_runtime!( + pub enum Test { + System: frame_system, + Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, + AccessSegregator: aga_access_segregator::{Pallet, Call, Storage, Event} = 2, + } +); + +parameter_types! { + pub const BlockHashCount: u64 = 250; + pub const MaximumBlockLength: u32 = 2 * 1024; + pub const AvailableBlockRatio: Perbill = Perbill::one(); + pub const MaxLocks: u32 = 100; + pub const MinimumPeriod: u64 = 1; +} + +impl frame_system::Config for Test { + type BaseCallFilter = frame_support::traits::Everything; + type Block = Block; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Nonce = u64; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId32; + type Lookup = IdentityLookup; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = (); + type OnSetCode = (); + type MaxConsumers = ConstU32<2>; +} + +parameter_types! { + pub const ExistentialDeposit: Balance = 1; +} + +impl pallet_balances::Config for Test { + type Balance = Balance; + type DustRemoval = (); + type RuntimeEvent = RuntimeEvent; + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = (); + type MaxLocks = (); + type MaxReserves = (); + type ReserveIdentifier = [u8; 8]; + type FreezeIdentifier = (); + type MaxFreezes = (); + type RuntimeHoldReason = (); + type MaxHolds = (); +} + +parameter_types! { + // Make sure put same value with `construct_runtime` + pub const PalletIndex: u8 = 2; + pub RegisteredExtrinsics: Vec<(u8, Vec)> = [ + (PalletIndex::get(), b"grant_access".to_vec()), + (PalletIndex::get(), b"unknown_extrinsic".to_vec()), + (PalletIndex::get(), b"unknown_extrinsic2".to_vec()), + ].to_vec(); +} + +impl aga_access_segregator::Config for Test { + type RuntimeEvent = RuntimeEvent; + type BridgeCommitteeOrigin = EnsureRoot; + type PalletIndex = PalletIndex; + type Extrinsics = RegisteredExtrinsics; + type WeightInfo = aga_access_segregator::weights::SygmaWeightInfo; +} + +pub fn new_test_ext() -> sp_io::TestExternalities { + let t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + let mut ext = sp_io::TestExternalities::new(t); + ext.execute_with(|| System::set_block_number(1)); + ext +} + +// Checks events against the latest. A contiguous set of events must be provided. They must +// include the most recent event, but do not have to include every past event. +pub fn assert_events(mut expected: Vec) { + let mut actual: Vec = + system::Pallet::::events().iter().map(|e| e.event.clone()).collect(); + + expected.reverse(); + + for evt in expected { + let next = actual.pop().expect("event expected"); + assert_eq!(next, evt, "Events don't match"); + } +} diff --git a/pallets/access-segregator/src/weights.rs b/pallets/access-segregator/src/weights.rs new file mode 100644 index 0000000..4a91911 --- /dev/null +++ b/pallets/access-segregator/src/weights.rs @@ -0,0 +1,61 @@ + +//! Autogenerated weights for `aga_access_segregator` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-04-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: +// ./target/release/standalone-node-template +// benchmark +// pallet +// --chain +// dev +// --execution=wasm +// --wasm-execution=compiled +// --pallet +// aga_access_segregator +// --extrinsic +// * +// --steps +// 50 +// --repeat +// 20 +// --output +// access_weight.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `aga_access_segregator`. +pub struct SygmaWeightInfo(PhantomData); +impl super::WeightInfo for SygmaWeightInfo { + /// Storage: SygmaAccessSegregator ExtrinsicAccess (r:0 w:1) + /// Proof Skipped: SygmaAccessSegregator ExtrinsicAccess (max_values: None, max_size: None, mode: Measured) + fn grant_access() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 9_000_000 picoseconds. + Weight::from_parts(9_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + + /// Storage: SygmaAccessSegregator ExtrinsicAccess (r:0 w:1) + /// Proof Skipped: SygmaAccessSegregator ExtrinsicAccess (max_values: None, max_size: None, mode: Measured) + fn revoke_access() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 9_000_000 picoseconds. + Weight::from_parts(9_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/pallets/bridge/Cargo.toml b/pallets/bridge/Cargo.toml new file mode 100644 index 0000000..71f4bd2 --- /dev/null +++ b/pallets/bridge/Cargo.toml @@ -0,0 +1,55 @@ +[package] +name = "aga-bridge" +description = "FRAME pallet template for defining custom runtime logic." +version = "0.1.0" +license = "Unlicense" +authors.workspace = true +homepage.workspace = true +repository.workspace = true +edition.workspace = true +publish = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { features = [ + "derive", +], workspace = true } +scale-info = { features = [ + "derive", +], workspace = true } +frame-benchmarking = { optional = true, workspace = true } +frame-support.workspace = true +frame-system.workspace = true +sp-io.workspace = true + +sp-api.workspace = true +aga-access-segregator.workspace = true +aga-primitives.workspace = true +primitive-types.workspace = true + +[dev-dependencies] +sp-core = { default-features = true, workspace = true } +sp-runtime = { default-features = true, workspace = true } + +[features] +default = ["std"] +std = [ + "codec/std", + "frame-benchmarking?/std", + "frame-support/std", + "frame-system/std", + "scale-info/std", + "aga-primitives/std", + "primitive-types/std", +] +runtime-benchmarks = [ + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", +] +try-runtime = [ + "frame-support/try-runtime", + "frame-system/try-runtime", +] diff --git a/pallets/bridge/src/benchmarking.rs b/pallets/bridge/src/benchmarking.rs new file mode 100644 index 0000000..1b8243e --- /dev/null +++ b/pallets/bridge/src/benchmarking.rs @@ -0,0 +1,35 @@ +//! Benchmarking setup for pallet-template +#![cfg(feature = "runtime-benchmarks")] +use super::*; + +#[allow(unused)] +use crate::Pallet as Template; +use frame_benchmarking::v2::*; +use frame_system::RawOrigin; + +#[benchmarks] +mod benchmarks { + use super::*; + + #[benchmark] + fn do_something() { + let value = 100u32.into(); + let caller: T::AccountId = whitelisted_caller(); + #[extrinsic_call] + do_something(RawOrigin::Signed(caller), value); + + assert_eq!(Something::::get(), Some(value)); + } + + #[benchmark] + fn cause_error() { + Something::::put(100u32); + let caller: T::AccountId = whitelisted_caller(); + #[extrinsic_call] + cause_error(RawOrigin::Signed(caller)); + + assert_eq!(Something::::get(), Some(101u32)); + } + + impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test); +} diff --git a/pallets/bridge/src/lib.rs b/pallets/bridge/src/lib.rs new file mode 100644 index 0000000..5cbbb40 --- /dev/null +++ b/pallets/bridge/src/lib.rs @@ -0,0 +1,657 @@ +// The Licensed Work is (c) 2022 Sygma +// SPDX-License-Identifier: LGPL-3.0-only + +#![cfg_attr(not(feature = "std"), no_std)] + +pub use self::pallet::*; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; +pub use weights::*; + +use aga_primitives::{ + ChainID, DomainID, DepositNonce +}; + +#[frame_support::pallet] +pub mod pallet { + // Import various useful types required by all FRAME pallets. + use super::*; + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + use frame_support::traits::fungible::{NativeOrWithId, Inspect, Mutate}; + use frame_support::traits::tokens::Preservation; + use scale_info::prelude::vec::Vec; + use primitive_types::U256; + use frame_support::PalletId; + use sp_io::hashing::keccak_256; + use frame_support::sp_runtime::traits::AccountIdConversion; + use frame_support::sp_runtime::{SaturatedConversion, Saturating}; + + #[derive(PartialEq, Eq, Clone, Encode, Decode, TypeInfo, RuntimeDebug)] + pub struct Proposal { + pub origin_domain_id: DomainID, + pub deposit_nonce: DepositNonce, + pub resource_id: [u8; 32], + pub data: Vec, + } + + // Allows easy access our Pallet's `Balance` type. Comes from `Fungible` interface. + pub type BalanceOf = + <::NativeBalances as Inspect<::AccountId>>::Balance; + // Allows Easy access to accounts + // let admin = T::Lookup::lookup(admin)?; + // pub type AccountIdLookupOf = <::Lookup as StaticLookup>::Source; + + // This includes the native and assets type + pub type NativeAndAssetId = NativeOrWithId; + + // The `Pallet` struct serves as a placeholder to implement traits, methods and dispatchables + // (`Call`s) in this pallet. + #[pallet::pallet] + pub struct Pallet(_); + + /// The pallet's configuration trait. + /// + /// All our types and constants a pallet depends on must be declared here. + /// These types are defined generically and made concrete when the pallet is declared in the + /// `runtime/src/lib.rs` file of your chain. + #[pallet::config] + pub trait Config: frame_system::Config + aga_access_segregator::Config { + /// The overarching runtime event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + /// the actual balance + type NativeBalances: Inspect + Mutate; + /// Type of asset class, sourced from [`Config::Assets`], utilized to offer liquidity to a + /// pool. + type AssetKind: Parameter + MaxEncodedLen; + /// Transfer reserve account holder + type TransferReserveAccount: Get; + /// Transfer reserve account holder + type FeeReserveAccount: Get; + /// Config ID for the current pallet instance + type PalletId: Get; + /// ResourceId type for 32-byte identifiers. + type ResourceId: Get<[u8; 32]>; + /// Current pallet index defined in runtime + type PalletIndex: Get; + /// A type representing the weights required by the dispatchables of this pallet. + type WeightInfo: WeightInfo; + } + + /// Mark supported dest domainID + #[pallet::storage] + #[pallet::getter(fn dest_domain_ids)] + pub type DestDomainIds = StorageMap<_, Twox64Concat, DomainID, bool, ValueQuery>; + + /// Mark the pairs for supported dest domainID with its corresponding chainID + /// The chainID is not directly used in pallet, this map is designed more about rechecking the + /// domainID + #[pallet::storage] + #[pallet::getter(fn dest_chain_ids)] + pub type DestChainIds = StorageMap<_, Twox64Concat, DomainID, ChainID>; + + /// Mapping fungible asset id to corresponding fee amount + #[pallet::storage] + #[pallet::getter(fn asset_fees)] + pub type AssetFees = StorageMap<_, Twox64Concat, DomainID, u128>; + + /// Deposit counter of dest domain + #[pallet::storage] + #[pallet::getter(fn deposit_counts)] + pub type DepositCounts = StorageMap<_, Twox64Concat, DomainID, DepositNonce, ValueQuery>; + + /// Bridge Pause indicator + /// Bridge is unpaused initially, until pause + /// After granted access setup, bridge should be paused until ready to unpause + #[pallet::storage] + #[pallet::getter(fn is_paused)] + pub type IsPaused = StorageMap<_, Twox64Concat, DomainID, bool, ValueQuery>; + + + /// Mark whether a deposit nonce was used. Used to mark execution status of a proposal. + #[pallet::storage] + #[pallet::getter(fn used_nonces)] + pub type UsedNonces = StorageDoubleMap< + _, + Twox64Concat, + DomainID, + Twox64Concat, + DepositNonce, + DepositNonce, + ValueQuery, + >; + + + #[allow(dead_code)] + #[pallet::event] + #[pallet::generate_deposit(pub (super) fn deposit_event)] + pub enum Event { + /// Deposit + Deposit { + dest_domain_id: DomainID, + resource_id: [u8; 32], + sender: T::AccountId, + deposit_nonce: DepositNonce, + deposit_data: Vec, + }, + /// When proposal was executed successfully + ProposalExecution { + origin_domain_id: DomainID, + deposit_nonce: DepositNonce, + data_hash: [u8; 32], + }, + /// When registering a new dest domainID with its corresponding chainID + RegisterDestDomain { + sender: T::AccountId, + domain_id: DomainID, + chain_id: ChainID + }, + /// When unregistering dest domainID with its corresponding chainID + UnregisterDestDomain { + sender: T::AccountId, + domain_id: DomainID, + chain_id: ChainID + }, + /// A user has successfully set a new value. + FeeSet { + /// The new value set. + domain_id: DomainID, + /// Amount + amount: u128 + }, + /// When bridge fee is collected + FeeCollected { + fee_payer: T::AccountId, + dest_domain_id: DomainID, + fee_amount: u128, + }, + /// When proposal was faild to execute + FailedHandlerExecution { + error: Vec, + origin_domain_id: DomainID, + deposit_nonce: DepositNonce, + }, + /// When all bridges are paused + AllBridgePaused { sender: T::AccountId }, + /// When all bridges are unpaused + AllBridgeUnpaused { sender: T::AccountId }, + /// When bridge is paused + /// args: [dest_domain_id] + BridgePaused { dest_domain_id: DomainID }, + /// When bridge is unpaused + /// args: [dest_domain_id] + BridgeUnpaused { dest_domain_id: DomainID }, + /// TEST + TestAddress { address: Vec } + } + + #[pallet::error] + pub enum Error { + /// Account has not gained access permission + AccessDenied, + DestDomainNotSupported, + DestChainIDNotMatch, + MissingFeeConfig, + InsufficientBalance, + DepositNonceOverflow, + EmptyProposalList, + ProposalAlreadyComplete, + InvalidDepositData, + Overflow, + Underflow, + InvalidDecimalConversion, + DecodingAccountIdFailed, + InvalidAccountId, + /// Bridge is paused + BridgePaused, + /// Bridge is unpaused + BridgeUnpaused, + } + + #[pallet::call] + impl Pallet { + /// Pause bridge, this would lead to bridge transfer failure before it being unpaused. + #[pallet::call_index(0)] + #[pallet::weight(< T as Config >::WeightInfo::pause_bridge())] + pub fn pause_bridge(origin: OriginFor, dest_domain_id: DomainID) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"pause_bridge".to_vec(), + origin + ), + Error::::AccessDenied + ); + ensure!(DestDomainIds::::get(dest_domain_id), Error::::DestDomainNotSupported); + + // Mark as paused + IsPaused::::insert(dest_domain_id, true); + + // Emit BridgePause event + Self::deposit_event(Event::BridgePaused { dest_domain_id }); + Ok(()) + } + + /// Unpause bridge. + #[pallet::call_index(1)] + #[pallet::weight(< T as Config >::WeightInfo::unpause_bridge())] + pub fn unpause_bridge(origin: OriginFor, dest_domain_id: DomainID) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"unpause_bridge".to_vec(), + origin + ), + Error::::AccessDenied + ); + ensure!(DestDomainIds::::get(dest_domain_id), Error::::DestDomainNotSupported); + + // make sure the current status is paused + ensure!(IsPaused::::get(dest_domain_id), Error::::BridgeUnpaused); + + // Mark as unpaused + IsPaused::::insert(dest_domain_id, false); + + // Emit BridgeUnpause event + Self::deposit_event(Event::BridgeUnpaused { dest_domain_id }); + Ok(()) + } + + + #[pallet::call_index(2)] + #[pallet::weight(::WeightInfo::register_domain())] + pub fn register_domain( + origin: OriginFor, + dest_domain_id: DomainID, + dest_chain_id: ChainID + ) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"register_domain".to_vec(), + origin.clone() + ), + Error::::AccessDenied + ); + + DestDomainIds::::insert(dest_domain_id, true); + DestChainIds::::insert(dest_domain_id, dest_chain_id); + + // Emit register dest domain event + let sender = ensure_signed(origin)?; + + Self::deposit_event(Event::RegisterDestDomain { + sender, + domain_id: dest_domain_id, + chain_id: dest_chain_id, + }); + + Ok(()) + } + + /// Mark the give dest domainID with chainID to be disabled + #[pallet::call_index(3)] + #[pallet::weight(< T as Config >::WeightInfo::unregister_domain())] + pub fn unregister_domain( + origin: OriginFor, + dest_domain_id: DomainID, + dest_chain_id: ChainID, + ) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"unregister_domain".to_vec(), + origin.clone() + ), + Error::::AccessDenied + ); + ensure!( + DestDomainIds::::get(dest_domain_id) + && DestChainIds::::get(dest_domain_id).is_some(), + Error::::DestDomainNotSupported + ); + + let co_chain_id = DestChainIds::::get(dest_domain_id).unwrap(); + ensure!(co_chain_id == dest_chain_id, Error::::DestChainIDNotMatch); + + DestDomainIds::::remove(dest_domain_id); + DestChainIds::::remove(dest_domain_id); + + // Emit register dest domain event + let sender = ensure_signed(origin)?; + + Self::deposit_event(Event::UnregisterDestDomain { + sender, + domain_id: dest_domain_id, + chain_id: dest_chain_id, + }); + + Ok(()) + } + + /// Mark the give dest domainID with chainID to be disabled + #[pallet::call_index(4)] + #[pallet::weight(< T as Config >::WeightInfo::deposit())] + pub fn deposit( + origin: OriginFor, + dest_domain_id: DomainID, + deposit_data: Vec, + ) -> DispatchResult { + let sender = ensure_signed(origin.clone())?; + ensure!( + DestDomainIds::::get(dest_domain_id), + Error::::DestDomainNotSupported + ); + + // Get the sender's current balance + let sender_balance = T::NativeBalances::balance(&sender); + + let (amount, recipient) = Self::extract_deposit_data(&deposit_data)?; + + ensure!(!IsPaused::::get(dest_domain_id), Error::::BridgePaused); + + // Let total amount to send in balance type + let amount_in_balance = amount.saturated_into::>(); + + // Ensure the sender has enough balance to cover both the transfer and the fee + ensure!( + sender_balance >= amount_in_balance, + Error::::InsufficientBalance + ); + + // Ensure fee is set + let fee = AssetFees::::get(dest_domain_id) + .ok_or(Error::::MissingFeeConfig)?; + + let fee_in_balance = fee.saturated_into::>(); + let fee_reserve_account = T::FeeReserveAccount::get(); + T::NativeBalances::transfer( + &sender, + &fee_reserve_account, + fee_in_balance, + Preservation::Expendable // Allow death + )?; + + Self::deposit_event(Event::FeeCollected { + fee_payer: sender.clone(), + dest_domain_id, + fee_amount: fee, + }); + + // net_amount_in_balance is amount after fees + let net_amount_in_balance = amount_in_balance.saturating_sub(fee_in_balance); + let transfer_reserve_account = T::TransferReserveAccount::get(); + T::NativeBalances::transfer( + &sender, + &transfer_reserve_account, + net_amount_in_balance, + Preservation::Expendable // Allow death + )?; + + // Bump deposit nonce + let deposit_nonce = DepositCounts::::get(dest_domain_id); + DepositCounts::::insert( + dest_domain_id, + deposit_nonce.checked_add(1).ok_or(Error::::DepositNonceOverflow)?, + ); + + // net_amount is the amount after all fees were deducted + let net_amount = amount + .checked_sub(fee) + .ok_or(Error::::Underflow)?; + + Self::deposit_event(Event::Deposit { + dest_domain_id, + resource_id: T::ResourceId::get(), + sender, + deposit_nonce, + deposit_data: Self::create_deposit_data(net_amount, recipient), + }); + + Ok(()) + } + + /// Mark the give dest domainID with chainID to be disabled + #[pallet::call_index(5)] + #[pallet::weight(::WeightInfo::execute_proposals(proposals.len() as u32))] + pub fn execute_proposals( + origin: OriginFor, + proposals: Vec, + ) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"execute_proposals".to_vec(), + origin.clone() + ), + Error::::AccessDenied + ); + // Ensure propsals is not empty + ensure!(!proposals.is_empty(), Error::::EmptyProposalList); + // Execute proposals one by one. + // Note if one proposal failed to execute, we emit `FailedHandlerExecution` rather + // than revert whole transaction + for proposal in proposals.iter() { + Self::execute_proposal_internal(proposal).map_or_else( + |e| { + let err_msg: &'static str = e.into(); + // Any error during proposal list execution will emit FailedHandlerExecution + Self::deposit_event(Event::FailedHandlerExecution { + error: err_msg.as_bytes().to_vec(), + origin_domain_id: proposal.origin_domain_id, + deposit_nonce: proposal.deposit_nonce, + }); + }, + |_| { + // Update proposal status + Self::set_proposal_executed( + proposal.deposit_nonce, + proposal.origin_domain_id, + ); + + // Emit ProposalExecution + Self::deposit_event(Event::ProposalExecution { + origin_domain_id: proposal.origin_domain_id, + deposit_nonce: proposal.deposit_nonce, + data_hash: keccak_256( + &[ + proposal.data.clone(), + T::PalletId::get().into_account_truncating(), + ] + .concat(), + ), + }); + }, + ); + } + + Ok(()) + } + + /// Mark the give dest domainID with chainID to be disabled + #[pallet::call_index(6)] + #[pallet::weight(< T as Config >::WeightInfo::set_fee())] + pub fn set_fee( + origin: OriginFor, + domain_id: DomainID, + amount: u128, + ) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"set_fee".to_vec(), + origin + ), + Error::::AccessDenied + ); + + // Ensure that domain is registered + ensure!(DestDomainIds::::get(domain_id), Error::::DestDomainNotSupported); + + // Update asset fee + AssetFees::::insert(domain_id, amount); + + // Emit FeeSet event + Self::deposit_event(Event::FeeSet { domain_id, amount }); + + Ok(()) + } + + /// Pause all registered bridges + #[pallet::call_index(7)] + #[pallet::weight(< T as Config >::WeightInfo::pause_all_bridges())] + pub fn pause_all_bridges(origin: OriginFor) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"pause_all_bridges".to_vec(), + origin.clone() + ), + Error::::AccessDenied + ); + + // Pause all bridges + Self::pause_all_domains(); + + // Emit AllBridgePaused + let sender = ensure_signed(origin)?; + Self::deposit_event(Event::AllBridgePaused { sender }); + + Ok(()) + } + + /// Unpause all registered bridges + #[pallet::call_index(8)] + #[pallet::weight(< T as Config >::WeightInfo::unpause_all_bridges())] + pub fn unpause_all_bridges(origin: OriginFor) -> DispatchResult { + ensure!( + >::has_access( + ::PalletIndex::get(), + b"unpause_all_bridges".to_vec(), + origin.clone() + ), + Error::::AccessDenied + ); + + // Unpause all bridges + Self::unpause_all_domains(); + + // Emit AllBridgeUnpaused + let sender = ensure_signed(origin)?; + Self::deposit_event(Event::AllBridgeUnpaused { sender }); + + Ok(()) + } + } + + impl Pallet { + pub fn create_deposit_data(amount: u128, recipient: Vec) -> Vec { + [ + &Self::hex_zero_padding_32(amount), + &Self::hex_zero_padding_32(recipient.len() as u128), // ETHEREUM Address length + recipient.as_slice(), + ] + .concat() + .to_vec() + } + + fn hex_zero_padding_32(i: u128) -> [u8; 32] { + let mut result = [0u8; 32]; + result[16..].copy_from_slice(&i.to_be_bytes()); + result + } + + /// Return true if deposit nonce has been used + pub fn is_proposal_executed(nonce: DepositNonce, domain_id: DomainID) -> bool { + (UsedNonces::::get(domain_id, nonce / 64) & (1 << (nonce % 64))) != 0 + } + + /// Set bit mask for specific nonce as used + fn set_proposal_executed(nonce: DepositNonce, domain_id: DomainID) { + let mut current_nonces = UsedNonces::::get(domain_id, nonce / 64); + current_nonces |= 1 << (nonce % 64); + UsedNonces::::insert(domain_id, nonce / 64, current_nonces); + } + + /// Execute a single proposal + fn execute_proposal_internal(proposal: &Proposal) -> DispatchResult { + // Check if domain is supported + ensure!( + DestDomainIds::::get(proposal.origin_domain_id), + Error::::DestDomainNotSupported + ); + + // Check if proposal has executed + ensure!( + !Self::is_proposal_executed(proposal.deposit_nonce, proposal.origin_domain_id), + Error::::ProposalAlreadyComplete + ); + + let (amount, recipient) = Self::extract_deposit_data(&proposal.data)?; + + // Let total amount to send in balance type + let amount_balance = amount.saturated_into::>(); + + let token_reserved_account = T::TransferReserveAccount::get(); + + // Decode recipient data into AccountId + let recipient_account_id = T::AccountId::decode(&mut &recipient[..]) + .map_err(|_| Error::::InvalidDepositData)?; + + T::NativeBalances::transfer( + &token_reserved_account, + &recipient_account_id, + amount_balance, + Preservation::Expendable // Allow death + )?; + + Ok(()) + } + + fn extract_deposit_data(data: &[u8]) -> Result<(u128, Vec), DispatchError> { + if data.len() < 64 { + return Err(Error::::InvalidDepositData.into()); + } + + // Extract the amount as u128 + let amount: u128 = U256::from_big_endian(&data[0..32]) + .try_into() + .map_err(|_| Error::::InvalidDepositData)?; + + // Extract recipient data length + let recipient_len: usize = U256::from_big_endian(&data[32..64]) + .try_into() + .map_err(|_| Error::::InvalidDepositData)?; + + if (data.len() - 64) < recipient_len { + return Err(Error::::InvalidDepositData.into()); + } + + let recipient = data[64..(64 + recipient_len)].to_vec(); + + // Return the amount and recipient + Ok((amount, recipient)) + } + + /// unpause all registered domains in the storage + fn unpause_all_domains() { + DestDomainIds::::iter_keys().for_each(|d| IsPaused::::insert(d, false)); + IsPaused::::iter_keys().for_each(|d| IsPaused::::insert(d, false)); + } + + /// pause all registered domains in the storage + fn pause_all_domains() { + DestDomainIds::::iter_keys().for_each(|d| IsPaused::::insert(d, true)); + IsPaused::::iter_keys().for_each(|d| IsPaused::::insert(d, true)); + } + } +} + +sp_api::decl_runtime_apis! { + /// This runtime api is for checking if the proposal is executed already + pub trait AgaBridgeApi { + fn is_proposal_executed(nonce: DepositNonce, domain_id: DomainID) -> bool; + } +} diff --git a/pallets/bridge/src/mock.rs b/pallets/bridge/src/mock.rs new file mode 100644 index 0000000..e69de29 diff --git a/pallets/bridge/src/tests.rs b/pallets/bridge/src/tests.rs new file mode 100644 index 0000000..68aa17b --- /dev/null +++ b/pallets/bridge/src/tests.rs @@ -0,0 +1,2 @@ +use crate::{mock::*, Error, Event, Something}; +use frame_support::{assert_noop, assert_ok}; diff --git a/pallets/bridge/src/weights.rs b/pallets/bridge/src/weights.rs new file mode 100644 index 0000000..ca27389 --- /dev/null +++ b/pallets/bridge/src/weights.rs @@ -0,0 +1,184 @@ + +//! Autogenerated weights for `aga_access_segregator` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-04-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: +// ./target/release/standalone-node-template +// benchmark +// pallet +// --chain +// dev +// --execution=wasm +// --wasm-execution=compiled +// --pallet +// aga_access_segregator +// --extrinsic +// * +// --steps +// 50 +// --repeat +// 20 +// --output +// access_weight.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use core::marker::PhantomData; + +pub trait WeightInfo { + fn pause_bridge() -> Weight; + fn unpause_bridge() -> Weight; + fn register_domain() -> Weight; + fn unregister_domain() -> Weight; + fn deposit() -> Weight; + fn execute_proposals(n: u32) -> Weight; + fn set_fee() -> Weight; + fn pause_all_bridges() -> Weight; + fn unpause_all_bridges() -> Weight; +} + +/// Weight functions for `aga_access_segregator`. +/// Weights for pallet_template using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); +impl WeightInfo for SubstrateWeight { + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn pause_bridge() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn unpause_bridge() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn register_domain() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn unregister_domain() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn deposit() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + + /// Storage: AgaBridge MpcAddr (r:1 w:0) + /// Proof Skipped: AgaBridge MpcAddr (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: AgaBridge IsPaused (r:1 w:0) + /// Proof Skipped: AgaBridge IsPaused (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestDomainIds (r:1 w:0) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge UsedNonces (r:1 w:1) + /// Proof Skipped: AgaBridge UsedNonces (max_values: None, max_size: None, mode: Measured) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// The range of component `n` is `[1, 1000]`. + fn execute_proposals(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `280` + // Estimated: `16593` + // Minimum execution time: 123_000_000 picoseconds. + Weight::from_parts(151_050_908, 0) + .saturating_add(Weight::from_parts(0, 16593)) + // Standard Error: 18_882 + .saturating_add(Weight::from_parts(10_748_102, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(2)) + } + + + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn set_fee() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn pause_all_bridges() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } + + /// Storage: AgaBridge DestDomainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestDomainIds (max_values: None, max_size: None, mode: Measured) + /// Storage: AgaBridge DestChainIds (r:0 w:1) + /// Proof Skipped: AgaBridge DestChainIds (max_values: None, max_size: None, mode: Measured) + fn unpause_all_bridges() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 10_000_000 picoseconds. + Weight::from_parts(10_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/primitives/aga/Cargo.toml b/primitives/aga/Cargo.toml new file mode 100644 index 0000000..f461a13 --- /dev/null +++ b/primitives/aga/Cargo.toml @@ -0,0 +1,31 @@ +[package] +name = "aga-primitives" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +homepage.workspace = true +repository.workspace = true +description = "Substrate runtime aga primitives" + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { features = [ + "derive", +], workspace = true } +scale-info = { features = [ + "derive", +], workspace = true } +sp-core = { workspace = true, default-features = false, features = [ + "serde", +] } + +[features] +default = ["std"] +std = [ + "codec/std", + "scale-info/std", + "sp-core/std", +] \ No newline at end of file diff --git a/primitives/aga/src/lib.rs b/primitives/aga/src/lib.rs new file mode 100644 index 0000000..6bc2f6d --- /dev/null +++ b/primitives/aga/src/lib.rs @@ -0,0 +1,32 @@ +// The Licensed Work is (c) 2022 Sygma +// SPDX-License-Identifier: LGPL-3.0-only + +#![cfg_attr(not(feature = "std"), no_std)] + +use sp_core::{H160, U256}; +use scale_info::TypeInfo; +use scale_info::prelude::vec::Vec; +use codec::{Decode, Encode}; + +pub type DomainID = u8; +pub type DepositNonce = u64; +pub type ChainID = U256; +pub type VerifyingContractAddress = H160; +pub type DestChainRecipient = Vec; +pub type DestinationLocation = (Vec, DomainID); +pub type AssetId = u32; +pub type ResourceId = [u8; 32]; +pub const AGA_NATIVE_ASSET_ID: u32 = 0; + + +#[derive(Clone, Debug, Eq, PartialEq, Encode, Decode, TypeInfo)] +pub enum TransferType { + FungibleTransfer, + NonFungibleTransfer, + GenericTransfer, +} + +pub trait DecimalConverter { + fn convert_to(amount: u128, decimal: u8) -> u128; + fn convert_from(amount: u128, decimal: u8) -> u128; +} \ No newline at end of file diff --git a/resources/aga-chain-spec-raw.json b/resources/aga-chain-spec-raw.json new file mode 100644 index 0000000..11e9ab0 --- /dev/null +++ b/resources/aga-chain-spec-raw.json @@ -0,0 +1,45 @@ +{ + "name": "Aga Testnet", + "id": "aga_testnet", + "chainType": "Live", + "bootNodes": [], + "telemetryEndpoints": null, + "protocolId": "aga", + "properties": { + "tokenSymbol": [ + "AGA" + ] + }, + "codeSubstitutes": {}, + "genesis": { + "raw": { + "top": { + "0x177e6857fb1d0e409376122fee3ad4f84e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9b28e9a2db83859d095177aa4ededd500eebd35f2ef78f22da6e0bd0d97dc9bac4aa41b274c609660a38202ad3585cd31": "0x000000000000000001000000000000000000a0dec5adc9353600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x91010c616761", + "0x3a636f6465": "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", + "0x3a65787472696e7369635f696e646578": "0x00000000", + "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", + "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x08b6ac2853ca8ac4754e43a2645da9c8398980f6b603ab02a758c82be3acb60c1fac52a5606019bf74c4173d7d90931b29c074965698682757bf23227b182ef14c", + "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xeebd35f2ef78f22da6e0bd0d97dc9bac4aa41b274c609660a38202ad3585cd31", + "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0500", + "0x5f9cc45b7a00c5899361e1c6099678dc5e0621c4869aa60c02be9adcc98a0d1d": "0x08048c83cb699b0b1a1defa30090c30da7df0eaa211ad8a476c1f3189413e921450100000000000000bb39f6ac7d43bd1d6db5dfd4983e8bfdd34c45ae267c3a82f197e99a1db57f9a0100000000000000", + "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000", + "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000", + "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0000a0dec5adc9353600000000000000", + "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" + }, + "childrenDefault": {} + } + } +} \ No newline at end of file diff --git a/resources/aga-chain-spec.json b/resources/aga-chain-spec.json new file mode 100644 index 0000000..223de0d --- /dev/null +++ b/resources/aga-chain-spec.json @@ -0,0 +1,50 @@ +{ + "name": "Aga Testnet", + "id": "aga_testnet", + "chainType": "Live", + "bootNodes": [], + "telemetryEndpoints": null, + "protocolId": "aga", + "properties": { + "tokenSymbol": [ + "AGA" + ] + }, + "codeSubstitutes": {}, + "genesis": { + "runtimeGenesis": { + "code": "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", + "patch": { + "aura": { + "authorities": [ + "5GCDiLxLqvEfiJSJz6h2JGQiF9pT1Ci2MKWG4SPSQ9X1mFF1", + "5FxeeKkGpE21wBGJYhhD7drVPYixgGiWGgnoknu3bha7fEq8" + ] + }, + "balances": { + "balances": [ + [ + "5HTjThDzsZuY7neTGTZrgJGKADHjyW9R4W3emZYJwZPa91gS", + 1000000000000000000000 + ] + ] + }, + "grandpa": { + "authorities": [ + [ + "5CAfnntejkHjFEAvmKMEpHcfG1qatgRGBLjF7dBkppfoUcwB", + 1 + ], + [ + "5GJC2iSZ6Ax3n4T1ZWzFHi2eqdxF7ptCLRFEstr7V6FKjyi7", + 1 + ] + ] + }, + "sudo": { + "key": "5HTjThDzsZuY7neTGTZrgJGKADHjyW9R4W3emZYJwZPa91gS" + } + } + } + } +} \ No newline at end of file diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 2f65e42..837accb 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -49,6 +49,14 @@ pallet-transaction-payment-rpc-runtime-api.workspace = true frame-benchmarking = { optional = true, workspace = true } frame-system-benchmarking = { optional = true, workspace = true } pallet-template.workspace = true +pallet-assets.workspace = true +pallet-asset-conversion.workspace = true +pallet-authorship.workspace = true +aga-access-segregator.workspace = true +aga-bridge.workspace = true +sp-staking.workspace = true +pallet-session.workspace = true +sp-std.workspace = true [build-dependencies] substrate-wasm-builder = { optional = true, workspace = true, default-features = true } @@ -68,7 +76,10 @@ std = [ "frame-benchmarking?/std", "frame-try-runtime?/std", - + + "pallet-authorship/std", + "pallet-asset-conversion/std", + "pallet-assets/std", "pallet-aura/std", "pallet-balances/std", "pallet-grandpa/std", @@ -77,6 +88,12 @@ std = [ "pallet-timestamp/std", "pallet-transaction-payment-rpc-runtime-api/std", "pallet-transaction-payment/std", + + "aga-access-segregator/std", + "aga-bridge/std", + "sp-staking/std", + "pallet-session/std", + "sp-std/std", "sp-api/std", "sp-block-builder/std", diff --git a/runtime/rustc-ice-2024-11-29T08_54_19-27816.txt b/runtime/rustc-ice-2024-11-29T08_54_19-27816.txt new file mode 100644 index 0000000..0466286 --- /dev/null +++ b/runtime/rustc-ice-2024-11-29T08_54_19-27816.txt @@ -0,0 +1,57 @@ +thread 'rustc' panicked at compiler/rustc_middle/src/ty/normalize_erasing_regions.rs:168:90: +Box +stack backtrace: + 0: 0x7f6b30974b25 - std::backtrace_rs::backtrace::libunwind::trace::h649ab3318d3445c5 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/../../backtrace/src/backtrace/libunwind.rs:116:5 + 1: 0x7f6b30974b25 - std::backtrace_rs::backtrace::trace_unsynchronized::hdf791dd7dc450a70 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/../../backtrace/src/backtrace/mod.rs:66:5 + 2: 0x7f6b30974b25 - std::backtrace::Backtrace::create::h0d35566749045048 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/backtrace.rs:331:13 + 3: 0x7f6b30974a75 - std::backtrace::Backtrace::force_capture::h004e136d8ed39e41 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/backtrace.rs:312:9 + 4: 0x7f6b33c9433e - std[1f2242ed6435445e]::panicking::update_hook::>::{closure#0} + 5: 0x7f6b3098f59f - as core::ops::function::Fn>::call::hce7569f4ca5d1b64 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/alloc/src/boxed.rs:2084:9 + 6: 0x7f6b3098f59f - std::panicking::rust_panic_with_hook::hfe205f6954b2c97b + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/panicking.rs:808:13 + 7: 0x7f6b33ccabd1 - std[1f2242ed6435445e]::panicking::begin_panic::::{closure#0} + 8: 0x7f6b33cbe496 - std[1f2242ed6435445e]::sys::backtrace::__rust_end_short_backtrace::::{closure#0}, !> + 9: 0x7f6b33cb98a6 - std[1f2242ed6435445e]::panicking::begin_panic:: + 10: 0x7f6b33cd3dd1 - ::emit_producing_guarantee + 11: 0x7f6b342b9904 - rustc_middle[ba2289ab3ae064d4]::util::bug::opt_span_bug_fmt::::{closure#0} + 12: 0x7f6b3429f49a - rustc_middle[ba2289ab3ae064d4]::ty::context::tls::with_opt::::{closure#0}, !>::{closure#0} + 13: 0x7f6b3429f31b - rustc_middle[ba2289ab3ae064d4]::ty::context::tls::with_context_opt::::{closure#0}, !>::{closure#0}, !> + 14: 0x7f6b31c3a600 - rustc_middle[ba2289ab3ae064d4]::util::bug::bug_fmt + 15: 0x7f6b358209a8 - >::fold_ty + 16: 0x7f6b35bacb7e - >::elaborate_drop + 17: 0x7f6b32027a94 - ::run_pass + 18: 0x7f6b3520197b - rustc_mir_transform[970027e2ae4dada5]::pass_manager::run_passes_inner + 19: 0x7f6b35c2b388 - rustc_mir_transform[970027e2ae4dada5]::mir_drops_elaborated_and_const_checked + 20: 0x7f6b35c2abbd - rustc_query_impl[3625cc0592f96219]::plumbing::__rust_begin_short_backtrace::> + 21: 0x7f6b35443c28 - rustc_query_system[200ca28aa7d9732c]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[3625cc0592f96219]::plumbing::QueryCtxt, false> + 22: 0x7f6b3544348d - rustc_query_impl[3625cc0592f96219]::query_impl::mir_drops_elaborated_and_const_checked::get_query_non_incr::__rust_end_short_backtrace + 23: 0x7f6b35a10f42 - rustc_interface[53a414ae04dc6ffb]::passes::analysis + 24: 0x7f6b35a105e7 - rustc_query_impl[3625cc0592f96219]::plumbing::__rust_begin_short_backtrace::> + 25: 0x7f6b3609ada2 - rustc_query_system[200ca28aa7d9732c]::query::plumbing::try_execute_query::>, false, false, false>, rustc_query_impl[3625cc0592f96219]::plumbing::QueryCtxt, false> + 26: 0x7f6b3609ab4f - rustc_query_impl[3625cc0592f96219]::query_impl::analysis::get_query_non_incr::__rust_end_short_backtrace + 27: 0x7f6b35f2c256 - rustc_interface[53a414ae04dc6ffb]::interface::run_compiler::, rustc_driver_impl[8683aa37472b7dde]::run_compiler::{closure#0}>::{closure#1} + 28: 0x7f6b35e7395b - std[1f2242ed6435445e]::sys::backtrace::__rust_begin_short_backtrace::, rustc_driver_impl[8683aa37472b7dde]::run_compiler::{closure#0}>::{closure#1}, core[3cad2706d8bdcdc4]::result::Result<(), rustc_span[28a649581f99a5bd]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[3cad2706d8bdcdc4]::result::Result<(), rustc_span[28a649581f99a5bd]::ErrorGuaranteed>> + 29: 0x7f6b35e7372a - <::spawn_unchecked_, rustc_driver_impl[8683aa37472b7dde]::run_compiler::{closure#0}>::{closure#1}, core[3cad2706d8bdcdc4]::result::Result<(), rustc_span[28a649581f99a5bd]::ErrorGuaranteed>>::{closure#0}::{closure#0}, core[3cad2706d8bdcdc4]::result::Result<(), rustc_span[28a649581f99a5bd]::ErrorGuaranteed>>::{closure#1} as core[3cad2706d8bdcdc4]::ops::function::FnOnce<()>>::call_once::{shim:vtable#0} + 30: 0x7f6b309995fb - as core::ops::function::FnOnce>::call_once::ha1963004222e7822 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/alloc/src/boxed.rs:2070:9 + 31: 0x7f6b309995fb - as core::ops::function::FnOnce>::call_once::h1086ced1f7c494c2 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/alloc/src/boxed.rs:2070:9 + 32: 0x7f6b309995fb - std::sys::pal::unix::thread::Thread::new::thread_start::ha8af9c992ef0b208 + at /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/std/src/sys/pal/unix/thread.rs:108:17 + 33: 0x7f6b3073dac3 - + 34: 0x7f6b307cf850 - + 35: 0x0 - + + +rustc version: 1.81.0 (eeb90cda1 2024-09-04) +platform: x86_64-unknown-linux-gnu + +query stack during panic: +#0 [mir_drops_elaborated_and_const_checked] elaborating drops for `::set_caller_from` +#1 [analysis] running analysis passes on this crate +end of query stack diff --git a/runtime/src/apis.rs b/runtime/src/apis.rs index 1e3dc45..981a5df 100644 --- a/runtime/src/apis.rs +++ b/runtime/src/apis.rs @@ -27,7 +27,7 @@ use alloc::{vec, vec::Vec}; use frame_support::{ genesis_builder_helper::{build_state, get_preset}, - weights::Weight, + weights::Weight }; use pallet_grandpa::AuthorityId as GrandpaId; use sp_api::impl_runtime_apis; @@ -39,6 +39,8 @@ use sp_runtime::{ ApplyExtrinsicResult, }; use sp_version::RuntimeVersion; +use crate::AssetConversion; +use crate::configs::NativeOrWithIdOf; // Local module imports use super::{ @@ -214,6 +216,44 @@ impl_runtime_apis! { } } + impl pallet_asset_conversion::AssetConversionApi for Runtime { + fn quote_price_exact_tokens_for_tokens( + asset1: NativeOrWithIdOf, + asset2: NativeOrWithIdOf, + amount: Balance, + include_fee: bool, + ) -> Option { + AssetConversion::quote_price_exact_tokens_for_tokens( + asset1, + asset2, + amount, + include_fee, + ) + } + + fn quote_price_tokens_for_exact_tokens( + asset1: NativeOrWithIdOf, + asset2: NativeOrWithIdOf, + amount: Balance, + include_fee: bool, + ) -> Option { + AssetConversion::quote_price_tokens_for_exact_tokens( + asset1, + asset2, + amount, + include_fee, + ) + } + + fn get_reserves( + asset1: NativeOrWithIdOf, + asset2: NativeOrWithIdOf, + ) -> Option<(Balance, Balance)> { + AssetConversion::get_reserves(asset1, asset2).ok() + } + } + + #[cfg(feature = "runtime-benchmarks")] impl frame_benchmarking::Benchmark for Runtime { fn benchmark_metadata(extra: bool) -> ( diff --git a/runtime/src/configs/mod.rs b/runtime/src/configs/mod.rs index a5c12fb..0d4ae96 100644 --- a/runtime/src/configs/mod.rs +++ b/runtime/src/configs/mod.rs @@ -25,18 +25,39 @@ // Substrate and Polkadot dependencies use frame_support::{ - derive_impl, parameter_types, - traits::{ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, VariantCountOf}, + derive_impl, parameter_types, ord_parameter_types, + traits::{ + fungible::{Balanced, Credit}, + OnUnbalanced, + tokens::{ + fungible::{NativeFromLeft, NativeOrWithId, UnionOf}, + imbalance::ResolveAssetTo + }, + ConstBool, ConstU128, ConstU32, ConstU64, ConstU8, VariantCountOf, + AsEnsureOriginWithArg + }, weights::{ constants::{RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND}, IdentityFee, Weight, }, + PalletId +}; +use frame_system::{ + limits::{BlockLength, BlockWeights}, + EnsureSigned,EnsureSignedBy,EnsureRoot }; -use frame_system::limits::{BlockLength, BlockWeights}; use pallet_transaction_payment::{ConstFeeMultiplier, FungibleAdapter, Multiplier}; +use pallet_asset_conversion::{AccountIdConverter, WithFirstAsset}; use sp_consensus_aura::sr25519::AuthorityId as AuraId; -use sp_runtime::{traits::One, Perbill}; +use sp_runtime::{ + traits::{One,AccountIdConversion}, + Perbill,Permill +}; use sp_version::RuntimeVersion; +// External crates imports +use alloc::{vec, vec::Vec}; +use crate::PoolAssets; +use crate::Assets; // Local module imports use super::{ @@ -93,7 +114,7 @@ impl frame_system::Config for Runtime { impl pallet_aura::Config for Runtime { type AuthorityId = AuraId; type DisabledValidators = (); - type MaxAuthorities = ConstU32<32>; + type MaxAuthorities = ConstU32<100_000>; type AllowMultipleBlocksPerSlot = ConstBool; type SlotDuration = pallet_aura::MinimumPeriodTimesTwo; } @@ -136,14 +157,31 @@ impl pallet_balances::Config for Runtime { type RuntimeFreezeReason = RuntimeHoldReason; } +/// Logic for the author to get a portion of fees. +pub struct ToAuthor(core::marker::PhantomData); +impl OnUnbalanced>> for ToAuthor +where + R: pallet_balances::Config + pallet_authorship::Config, + ::AccountId: From, + ::AccountId: Into, +{ + fn on_nonzero_unbalanced( + amount: Credit<::AccountId, pallet_balances::Pallet>, + ) { + if let Some(author) = >::author() { + let _ = >::resolve(&author, amount); + } + } +} + parameter_types! { pub FeeMultiplier: Multiplier = Multiplier::one(); } impl pallet_transaction_payment::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type OnChargeTransaction = FungibleAdapter; - type OperationalFeeMultiplier = ConstU8<5>; + type OnChargeTransaction = FungibleAdapter>; + type OperationalFeeMultiplier = ConstU8<100>; type WeightToFee = IdentityFee; type LengthToFee = IdentityFee; type FeeMultiplierUpdate = ConstFeeMultiplier; @@ -160,3 +198,181 @@ impl pallet_template::Config for Runtime { type RuntimeEvent = RuntimeEvent; type WeightInfo = pallet_template::weights::SubstrateWeight; } + +pub const MILLICENTS: Balance = 1_000_000_000; +pub const CENTS: Balance = 1_000 * MILLICENTS; // assume this is worth about a cent. +pub const DOLLARS: Balance = 100 * CENTS; + +parameter_types! { + pub const AssetDeposit: Balance = 50 * DOLLARS; + pub const ApprovalDeposit: Balance = 1 * DOLLARS; + pub const StringLimit: u32 = 50; + pub const MetadataDepositBase: Balance = 10 * DOLLARS; + pub const MetadataDepositPerByte: Balance = 1 * DOLLARS; +} + +pub type TrustBackedAssetsInstance = pallet_assets::Instance1; +impl pallet_assets::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = u128; + type AssetId = u32; + type AssetIdParameter = codec::Compact; + type CreateOrigin = AsEnsureOriginWithArg>; + type Currency = Balances; + type ForceOrigin = frame_system::EnsureRoot; + type AssetDeposit = AssetDeposit; + type AssetAccountDeposit = ConstU128; + type MetadataDepositBase = MetadataDepositBase; + type MetadataDepositPerByte = MetadataDepositPerByte; + type ApprovalDeposit = ApprovalDeposit; + type StringLimit = StringLimit; + type Freezer = (); + type Extra = (); + type WeightInfo = pallet_assets::weights::SubstrateWeight; + type RemoveItemsLimit = ConstU32<1000>; + type CallbackHandle = (); +} + +parameter_types! { + pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon"); + pub const Native: NativeOrWithIdOf = NativeOrWithId::Native; + pub storage LiquidityWithdrawalFee: Permill = Permill::from_percent(0); +} + +ord_parameter_types! { + pub const AssetConversionOrigin: sp_runtime::AccountId32 = + AccountIdConversion::::into_account_truncating(&AssetConversionPalletId::get()); +} +/// We allow root to execute privileged asset operations. +pub type AssetsForceOrigin = EnsureRoot; +pub type PoolAssetsInstance = pallet_assets::Instance2; +impl pallet_assets::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type RemoveItemsLimit = ConstU32<1000>; + type AssetId = u32; + type AssetIdParameter = u32; + type Currency = Balances; + type CreateOrigin = + AsEnsureOriginWithArg>; + type ForceOrigin = AssetsForceOrigin; + // Deposits are zero because creation/admin is limited to Asset Conversion pallet. + type AssetDeposit = ConstU128<0>; + type AssetAccountDeposit = ConstU128<0>; + type MetadataDepositBase = ConstU128<0>; + type MetadataDepositPerByte = ConstU128<0>; + type ApprovalDeposit = ApprovalDeposit; + type StringLimit = ConstU32<50>; + type Freezer = (); + type Extra = (); + type WeightInfo = pallet_assets::weights::SubstrateWeight; + type CallbackHandle = (); + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = (); +} + +pub type NativeOrWithIdOf = NativeOrWithId; +pub type NativeAndAssets = UnionOf; +pub type PoolIdToAccountId = AccountIdConverter; + +impl pallet_asset_conversion::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = ::Balance; + type HigherPrecisionBalance = u128; + type AssetKind = NativeOrWithIdOf; + type Assets = NativeAndAssets; + type PoolId = (Self::AssetKind, Self::AssetKind); + type PoolLocator = WithFirstAsset; + type PoolAssetId = u32; + type PoolAssets = PoolAssets; + type PoolSetupFee = ConstU128<100>; // should be more or equal to the existential deposit + type PoolSetupFeeAsset = Native; + type PoolSetupFeeTarget = ResolveAssetTo; + type PalletId = AssetConversionPalletId; + type WeightInfo = (); + type LPFee = ConstU32<3>; // means 0.3% + type LiquidityWithdrawalFee = LiquidityWithdrawalFee; + type MaxSwapPathLength = ConstU32<4>; + type MintMinLiquidity = ConstU128<100>; // 100 is good enough when the main currency has 12 decimals. + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = (); +} + +pub struct AuraAccountAdapter; +impl frame_support::traits::FindAuthor for AuraAccountAdapter { + fn find_author<'a, I>(digests: I) -> Option + where I: 'a + IntoIterator + { + pallet_aura::AuraAuthorId::::find_author(digests).and_then(|k| { + AccountId::try_from(k.as_ref()).ok() + }) + } +} + +impl pallet_authorship::Config for Runtime { + type FindAuthor = AuraAccountAdapter; + type EventHandler = (); +} + +parameter_types! { + // Make sure put same value with `construct_runtime` + pub const AccessSegregatorPalletIndex: u8 = 12; + pub const BridgePalletIndex: u8 = 13; + // pub const BasicFeeHandlerPalletIndex: u8 = 10; + // pub const FeeHandlerRouterPalletIndex: u8 = 12; + // pub const PercentageFeeHandlerRouterPalletIndex: u8 = 13; + // RegisteredExtrinsics here registers all valid (pallet index, extrinsic_name) paris + // make sure to update this when adding new access control extrinsic + pub RegisteredExtrinsics: Vec<(u8, Vec)> = [ + (AccessSegregatorPalletIndex::get(), b"grant_access".to_vec()), + (BridgePalletIndex::get(), b"register_domain".to_vec()), + (BridgePalletIndex::get(), b"unregister_domain".to_vec()), + (BridgePalletIndex::get(), b"transfer".to_vec()), + (BridgePalletIndex::get(), b"set_fee".to_vec()), + (BridgePalletIndex::get(), b"deposit".to_vec()), + (BridgePalletIndex::get(), b"execute_proposals".to_vec()), + (BridgePalletIndex::get(), b"pause_bridge".to_vec()), + (BridgePalletIndex::get(), b"unpause_bridge".to_vec()), + (BridgePalletIndex::get(), b"pause_all_bridges".to_vec()), + (BridgePalletIndex::get(), b"unpause_all_bridges".to_vec()), + // (BridgePalletIndex::get(), b"retry".to_vec()), + // (FeeHandlerRouterPalletIndex::get(), b"set_fee_handler".to_vec()), + // (PercentageFeeHandlerRouterPalletIndex::get(), b"set_fee_rate".to_vec()), + ].to_vec(); +} + + +impl aga_access_segregator::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type BridgeCommitteeOrigin = frame_system::EnsureRoot; + type PalletIndex = AccessSegregatorPalletIndex; + type Extrinsics = RegisteredExtrinsics; + type WeightInfo = aga_access_segregator::weights::SygmaWeightInfo; +} + +parameter_types! { + // TreasuryAccount is an substrate account and currently used for substrate -> EVM bridging fee collection + // TreasuryAccount address: 5ELLU7ibt5ZrNEYRwohtaRBDBa3TzcWwwPELBPSWWd2mbgv3 + pub BridgeAccountNativeFee: AccountId = AccountId::new([100u8; 32]); + // BridgeAccountNative: 5EYCAe5jLbHcAAMKvLFSXgCTbPrLgBJusvPwfKcaKzuf5X5e + pub BridgeAccountNative: AccountId = AgaBridgePalletId::get().into_account_truncating(); + // AgaBridgePalletId is the palletIDl + // this is used as the replacement of handler address in the ProposalExecution event + pub const AgaBridgePalletId: PalletId = PalletId(*b"aga/0001"); + /// Native asset's ResourceId. + pub const AgaResourceId: [u8; 32] = [0u8; 32]; +} + +// This bridge only support AGA Coin +impl aga_bridge::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type AssetKind = Balance; + type NativeBalances = Balances; + type TransferReserveAccount = BridgeAccountNative; + type FeeReserveAccount = BridgeAccountNativeFee; + type PalletId = AgaBridgePalletId; + type PalletIndex = BridgePalletIndex; + type ResourceId = AgaResourceId; + type WeightInfo = aga_bridge::weights::SubstrateWeight; +} + diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 6cbfbb8..b5d2e95 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -59,8 +59,8 @@ impl_opaque_keys! { // https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning #[sp_version::runtime_version] pub const VERSION: RuntimeVersion = RuntimeVersion { - spec_name: create_runtime_str!("solochain-template-runtime"), - impl_name: create_runtime_str!("solochain-template-runtime"), + spec_name: create_runtime_str!("aga-testnet"), + impl_name: create_runtime_str!("aga-testnet"), authoring_version: 1, // The version of the runtime specification. A full node will not attempt to use its native // runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`, @@ -180,7 +180,23 @@ pub type Executive = frame_executive::Executive< Migrations, >; -// Create the runtime by composing the FRAME pallets that were previously configured. +// // Create the runtime by composing the FRAME pallets that were previously configured. +// construct_runtime!( +// pub enum Runtime +// { +// // System support stuff. +// System: frame_system = 0, +// Timestamp: pallet_timestamp = 1, +// Aura: pallet_aura = 2, +// Grandpa: pallet_grandpa = 3; +// Balances: pallet_balances = 4; +// TransactionPayment: pallet_transaction_payment = 5; +// Sudo: pallet_sudo = 6; +// TemplateModule: pallet_template = 7; +// Assets: pallet_assets:: = 8; +// } +// ); + #[frame_support::runtime] mod runtime { #[runtime::runtime] @@ -221,4 +237,22 @@ mod runtime { // Include the custom logic from the pallet-template in the runtime. #[runtime::pallet_index(7)] pub type TemplateModule = pallet_template; + + #[runtime::pallet_index(8)] + pub type Assets = pallet_assets; + + #[runtime::pallet_index(9)] + pub type PoolAssets = pallet_assets; + + #[runtime::pallet_index(10)] + pub type AssetConversion = pallet_asset_conversion; + + #[runtime::pallet_index(11)] + pub type Authorship = pallet_authorship; + + #[runtime::pallet_index(12)] + pub type AgaAccessSegregator = aga_access_segregator; + + #[runtime::pallet_index(13)] + pub type AgaBridge = aga_bridge; }