Stream Payment pallet

Cargo.toml

@@ -35,6 +35,7 @@ pallet-pooled-staking = { path = "pallets/pooled-staking", default-features = fa
 pallet-registrar = { path = "pallets/registrar", default-features = false }
 pallet-registrar-runtime-api = { path = "pallets/registrar/rpc/runtime-api", default-features = false }
 pallet-services-payment = { path = "pallets/services-payment", default-features = false }
+pallet-stream-payment = { path = "pallets/stream-payment", default-features = false }
 
 container-chain-template-frontier-runtime = { path = "container-chains/templates/frontier/runtime", default-features = false }
 container-chain-template-simple-runtime = { path = "container-chains/templates/simple/runtime", default-features = false }
@@ -47,6 +48,7 @@ tc-consensus = { path = "client/consensus" }
 tp-author-noting-inherent = { path = "primitives/author-noting-inherent", default-features = false }
 tp-consensus = { path = "primitives/consensus", default-features = false }
 tp-container-chain-genesis-data = { path = "primitives/container-chain-genesis-data", default-features = false }
+tp-fungibles-ext = { path = "primitives/fungibles-ext", default-features = false }
 tp-maths = { path = "primitives/maths", default-features = false }
 tp-traits = { path = "primitives/traits", default-features = false }
 
@@ -248,6 +250,7 @@ num_enum = { version = "0.7.1", default-features = false }
 rand_chacha = { version = "0.3.1", default-features = false }
 serde = { version = "1.0.152", default-features = false }
 smallvec = "1.10.0"
+tap = "1.0.1"
 
 # General (client)
 async-io = "1.3"

pallets/collator-assignment/src/assignment.rs

@@ -20,8 +20,8 @@ use {
         cmp,
         collections::{btree_map::BTreeMap, btree_set::BTreeSet},
         marker::PhantomData,
-        mem, vec,
-        vec::Vec,
+        mem,
+        vec::{self, Vec},
     },
     tp_traits::{ParaId, RemoveInvulnerables as RemoveInvulnerablesT},
 };

pallets/collator-assignment/src/tests.rs

@@ -14,9 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with Tanssi.  If not, see <http://www.gnu.org/licenses/>
 
-use dp_collator_assignment::AssignedCollators;
 use {
     crate::{mock::*, CollatorContainerChain, Event, PendingCollatorContainerChain},
+    dp_collator_assignment::AssignedCollators,
     std::collections::BTreeMap,
 };
 

pallets/collator-assignment/src/tests/assign_full.rs

@@ -14,9 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Tanssi.  If not, see <http://www.gnu.org/licenses/>
 
-use crate::assignment::AssignmentError;
 use {
-    crate::{assignment::Assignment, tests::Test},
+    crate::{
+        assignment::{Assignment, AssignmentError},
+        tests::Test,
+    },
     sp_std::collections::btree_map::BTreeMap,
 };
 

pallets/stream-payment/Cargo.toml

@@ -0,0 +1,66 @@
+[package]
+name = "pallet-stream-payment"
+authors = { workspace = true }
+description = "Stream payment pallet"
+edition = "2021"
+license = "GPL-3.0-only"
+version = "0.1.0"
+
+[package.metadata.docs.rs]
+targets = [ "x86_64-unknown-linux-gnu" ]
+
+[dependencies]
+log = { workspace = true }
+serde = { workspace = true, optional = true }
+
+dp-core = { workspace = true }
+tp-maths = { workspace = true }
+tp-traits = { workspace = true }
+
+# Substrate
+frame-benchmarking = { workspace = true, optional = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+parity-scale-codec = { workspace = true }
+scale-info = { workspace = true }
+sp-core = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+
+[dev-dependencies]
+num-traits = { workspace = true }
+pallet-balances = { workspace = true, features = [ "std" ] }
+similar-asserts = { workspace = true }
+sp-io = { workspace = true, features = [ "std" ] }
+tap = { workspace = true }
+
+[features]
+default = [ "std" ]
+std = [
+	"dp-core/std",
+	"frame-benchmarking/std",
+	"frame-support/std",
+	"frame-system/std",
+	"log/std",
+	"pallet-balances/std",
+	"parity-scale-codec/std",
+	"scale-info/std",
+	"serde",
+	"serde?/std",
+	"sp-core/std",
+	"sp-io/std",
+	"sp-runtime/std",
+	"sp-std/std",
+	"tp-maths/std",
+	"tp-traits/std",
+]
+runtime-benchmarks = [
+	"frame-benchmarking",
+	"frame-benchmarking/runtime-benchmarks",
+	"frame-support/runtime-benchmarks",
+	"frame-system/runtime-benchmarks",
+	"pallet-balances/runtime-benchmarks",
+	"sp-runtime/runtime-benchmarks",
+	"tp-maths/runtime-benchmarks",
+	"tp-traits/runtime-benchmarks",
+]

pallets/stream-payment/src/benchmarking.rs

@@ -0,0 +1,127 @@
+// Copyright (C) Moondance Labs Ltd.
+// This file is part of Tanssi.
+
+// Tanssi is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Tanssi 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 General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Tanssi.  If not, see <http://www.gnu.org/licenses/>
+
+use {
+    crate::{Assets, Call, Config, Event, Pallet, StreamConfig, TimeProvider},
+    frame_benchmarking::{account, impl_benchmark_test_suite, v2::*, BenchmarkError},
+    frame_support::{assert_ok, dispatch::RawOrigin},
+    frame_system::EventRecord,
+    sp_std::vec,
+};
+
+/// Create a funded user.
+fn create_funded_user<T: Config>(
+    string: &'static str,
+    n: u32,
+    asset_id: &T::AssetId,
+    amount: T::Balance,
+) -> T::AccountId {
+    const SEED: u32 = 0;
+    let user = account(string, n, SEED);
+    T::Assets::bench_set_balance(asset_id, &user, amount);
+    user
+}
+
+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 open_stream() -> Result<(), BenchmarkError> {
+        let asset_id = T::Assets::bench_asset_id();
+        let time_unit = T::TimeProvider::bench_time_unit();
+
+        let source = create_funded_user::<T>("source", 1, &asset_id, 1_000_000_000u32.into());
+        let target = create_funded_user::<T>("target", 2, &asset_id, 1_000_000_000u32.into());
+
+        #[extrinsic_call]
+        _(
+            RawOrigin::Signed(source.clone()),
+            target,
+            StreamConfig {
+                time_unit,
+                asset_id,
+                rate: 100u32.into(),
+            },
+            1_000_000u32.into(),
+        );
+
+        assert_last_event::<T>(
+            Event::StreamOpened {
+                stream_id: 0u32.into(),
+            }
+            .into(),
+        );
+
+        Ok(())
+    }
+
+    #[benchmark]
+    fn close_stream() -> Result<(), BenchmarkError> {
+        // Worst case is closing a stream with a pending payment.
+        let time_unit = T::TimeProvider::bench_time_unit();
+        let asset_id = T::Assets::bench_asset_id();
+
+        let source = create_funded_user::<T>("source", 1, &asset_id, 1_000_000_000u32.into());
+        let target = create_funded_user::<T>("target", 2, &asset_id, 1_000_000_000u32.into());
+
+        let rate = 100u32.into();
+        let initial_deposit = 1_000_000u32.into();
+
+        assert_ok!(Pallet::<T>::open_stream(
+            RawOrigin::Signed(source.clone()).into(),
+            target,
+            StreamConfig {
+                time_unit: time_unit.clone(),
+                asset_id,
+                rate,
+            },
+            initial_deposit,
+        ));
+
+        // Change time to trigger payment.
+        let now = T::TimeProvider::now(&time_unit).expect("can fetch time");
+        let delta: T::Balance = 10u32.into();
+        T::TimeProvider::bench_set_now(now + delta);
+
+        #[extrinsic_call]
+        _(RawOrigin::Signed(source.clone()), 0u32.into());
+
+        assert_last_event::<T>(
+            Event::StreamClosed {
+                stream_id: 0u32.into(),
+                refunded: initial_deposit - (rate * delta),
+            }
+            .into(),
+        );
+
+        Ok(())
+    }
+
+    impl_benchmark_test_suite!(
+        Pallet,
+        crate::mock::ExtBuilder::default().build(),
+        crate::mock::Runtime,
+    );
+}