feat(TimeRelease): add ability to cancel scheduled transfers (#2292)

Add ability cancel a scheduled transfer by providing a unique
identifier.
When a transfer is canceled, any held funds are released. Scheduled
transfers now
require a unique identifier at the time of creation, which is used to
reference and manage each transfer.

Closes #2275

Author: enddynayn

.github/workflows/common/codecov/action.yml

@@ -9,7 +9,7 @@ runs:
   steps:
     - name: Install grcov
       shell: bash
-      run: cargo install --locked grcov
+      run: cargo install --locked grcov --version 0.8.20
     - name: Build
       shell: bash # Limited to 10 threads max
       run: cargo build -j 10 --features frequency-lint-check

e2e/package-lock.json

@@ -3,7 +3,12 @@ import { ApiPromise, ApiRx } from '@polkadot/api';
 import { ApiTypes, AugmentedEvent, SubmittableExtrinsic, SignerOptions } from '@polkadot/api/types';
 import { KeyringPair } from '@polkadot/keyring/types';
 import { Compact, u128, u16, u32, u64, Vec, Option, Bool } from '@polkadot/types';
-import { FrameSystemAccountInfo, SpRuntimeDispatchError } from '@polkadot/types/lookup';
+import {
+  FrameSystemAccountInfo,
+  PalletTimeReleaseReleaseSchedule,
+  SpRuntimeDispatchError,
+  PalletSchedulerScheduled,
+} from '@polkadot/types/lookup';
 import { AnyJson, AnyNumber, AnyTuple, Codec, IEvent, ISubmittableResult } from '@polkadot/types/types';
 import { firstValueFrom, filter, map, pipe, tap } from 'rxjs';
 import { getBlockNumber, getExistentialDeposit, getFinalizedBlockNumber, log, MultiSignatureType } from './helpers';
@@ -784,6 +789,28 @@ export class ExtrinsicHelper {
     );
   }
 
+  public static timeReleaseScheduleNamedTransfer(
+    keys: KeyringPair,
+    id: Uint8Array,
+    who: KeyringPair,
+    schedule: ReleaseSchedule,
+    when: number
+  ) {
+    return new Extrinsic(
+      () => ExtrinsicHelper.api.tx.timeRelease.scheduleNamedTransfer(id, getUnifiedAddress(who), schedule, when),
+      keys,
+      ExtrinsicHelper.api.events.scheduler.Scheduled
+    );
+  }
+
+  public static timeReleaseCancelScheduledNamedTransfer(keys: KeyringPair, id: Uint8Array) {
+    return new Extrinsic(
+      () => ExtrinsicHelper.api.tx.timeRelease.cancelScheduledNamedTransfer(id),
+      keys,
+      ExtrinsicHelper.api.events.scheduler.Canceled
+    );
+  }
+
   public static claimHandle(delegatorKeys: KeyringPair, payload: any) {
     const proof = { Sr25519: u8aToHex(delegatorKeys.sign(u8aWrapBytes(payload.toU8a()))) };
     return new Extrinsic(

e2e/scaffolding/extrinsicHelpers.ts

@@ -1,6 +1,6 @@
 import '@frequency-chain/api-augment';
 import assert from 'assert';
-import { createAndFundKeypair } from '../scaffolding/helpers';
+import { createAndFundKeypair, getBlockNumber } from '../scaffolding/helpers';
 import { KeyringPair } from '@polkadot/keyring/types';
 import { ExtrinsicHelper, ReleaseSchedule } from '../scaffolding/extrinsicHelpers';
 import { getFundingSource } from '../scaffolding/funding';
@@ -50,4 +50,92 @@ describe('TimeRelease', function () {
       assert.notEqual(target, undefined, 'should have returned ReleaseScheduleAdded event');
     });
   });
+
+  describe('Schedule transfers', function () {
+    it('create a schedule transfer and cancel', async function () {
+      const amount = 100000n * BigInt(DOLLARS);
+      const schedule: ReleaseSchedule = calculateReleaseSchedule(amount);
+      const currentBlock = await getBlockNumber();
+
+      const scheduleName1 = new Uint8Array(32).fill(1);
+      const scheduleName2 = new Uint8Array(32).fill(2);
+
+      const scheduleTransferTx1 = ExtrinsicHelper.timeReleaseScheduleNamedTransfer(
+        fundingSource,
+        scheduleName1,
+        vesterKeys,
+        schedule,
+        currentBlock + 20
+      );
+      const scheduleTransferTx2 = ExtrinsicHelper.timeReleaseScheduleNamedTransfer(
+        fundingSource,
+        scheduleName2,
+        vesterKeys,
+        schedule,
+        currentBlock + 20
+      );
+      const { target: target1 } = await scheduleTransferTx1.signAndSend();
+      const { target: target2 } = await scheduleTransferTx2.signAndSend();
+      assert.notEqual(target1, undefined, 'should have returned Scheduled event');
+      assert.notEqual(target2, undefined, 'should have returned Scheduled event');
+
+      const reservedAmountBefore =
+        await ExtrinsicHelper.apiPromise.query.timeRelease.scheduleReservedAmounts(scheduleName1);
+
+      assert.equal('10,000,000,000,000', reservedAmountBefore.toHuman());
+
+      await ExtrinsicHelper.runToBlock(currentBlock + 2);
+
+      const cancelScheduleTransferTx1 = await ExtrinsicHelper.timeReleaseCancelScheduledNamedTransfer(
+        fundingSource,
+        scheduleName1
+      );
+      const { target: cancelTarget1 } = await cancelScheduleTransferTx1.signAndSend();
+      assert.notEqual(cancelTarget1, undefined, 'should have returned scheduler Canceled event');
+
+      const reservedAmountAfter =
+        await ExtrinsicHelper.apiPromise.query.timeRelease.scheduleReservedAmounts(scheduleName1);
+      assert.equal(true, reservedAmountAfter.isEmpty, 'reserved amount should be empty');
+
+      const cancelScheduleTransferTx2 = await ExtrinsicHelper.timeReleaseCancelScheduledNamedTransfer(
+        fundingSource,
+        scheduleName2
+      );
+
+      const { target: cancelTarget2 } = await cancelScheduleTransferTx2.signAndSend();
+
+      assert.notEqual(cancelTarget2, undefined, 'should have returned scheduler Canceled event');
+    });
+  });
+
+  describe('create schedule', function () {
+    it('create a schedule transfer', async function () {
+      const amount = 100000n * BigInt(DOLLARS);
+      const schedule: ReleaseSchedule = calculateReleaseSchedule(amount);
+      const currentBlock = await getBlockNumber();
+
+      const scheduleName1 = new Uint8Array(32).fill(1);
+
+      const scheduleTransferTx1 = ExtrinsicHelper.timeReleaseScheduleNamedTransfer(
+        fundingSource,
+        scheduleName1,
+        vesterKeys,
+        schedule,
+        currentBlock + 10
+      );
+      const { target: target1 } = await scheduleTransferTx1.signAndSend();
+      assert.notEqual(target1, undefined, 'should have returned Scheduled event');
+
+      const reservedAmountBefore =
+        await ExtrinsicHelper.apiPromise.query.timeRelease.scheduleReservedAmounts(scheduleName1);
+
+      assert.equal('10,000,000,000,000', reservedAmountBefore.toHuman());
+
+      await ExtrinsicHelper.runToBlock(currentBlock + 15);
+
+      const reservedAmountAfter =
+        await ExtrinsicHelper.apiPromise.query.timeRelease.scheduleReservedAmounts(scheduleName1);
+      assert.equal(true, reservedAmountAfter.isEmpty, 'reserved amount should be empty');
+    });
+  });
 });

e2e/time-release/timeRelease.test.ts

@@ -40,8 +40,8 @@ When a particular amount of tokens become eligible for release based on their ve
 | Name/Description                                                                            | Caller            | Payment | Key Events                                                                                                                                          | Runtime Added |
 | ------------------------------------------------------------------------------------------- | ----------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- |
 | `transfer`<br />Transfer tokens to another account with an unlock schedule                  | Token Account     | Tokens  | [`ReleaseScheduleAdded`](https://frequency-chain.github.io/frequency/pallet_time_release/pallet/enum.Event.html#variant.ReleaseScheduleAdded)       | 24            |
-| `schedule_transfer`<br />Lock tokens in a sender's account for later execution of the `execute_scheduled_transfer` extrinsic at a pre-determined block number | Token Account | Tokens | \<see scheduler pallet\>| 144
-| `execute_scheduled_transfer`<br />Executes a scheduled transfer that was previously scheduled using the `schedule_transfer` extrinsic. | Scheduler pallet | Tokens | `ReleaseScheduleAdded` | 144
+| `schedule_transfer`<br />Lock tokens in a sender's account for later execution of the `execute_scheduled_named_transfer` extrinsic at a pre-determined block number | Token Account | Tokens | \<see scheduler pallet\>| 144
+| `execute_scheduled_named_transfer`<br />Executes a scheduled transfer that was previously scheduled using the `schedule_transfer` extrinsic. | Scheduler pallet | Tokens | `ReleaseScheduleAdded` | 144
 | `claim`<br />Remove the lock on tokens for the calling account when the schedule allows     | Account with Lock | Tokens  | [`Claimed`](https://frequency-chain.github.io/frequency/pallet_time_release/pallet/enum.Event.html#variant.Claimed)                                 | 24            |
 | `claim_for`<br />Remove the lock on tokens for a different account when the schedule allows | Any Token Account | Tokens  | [`Claimed`](https://frequency-chain.github.io/frequency/pallet_time_release/pallet/enum.Event.html#variant.Claimed)                                 | 24            |
 | `update_release_schedules`<br />Governance action to update existing schedules              | Governance        | Tokens  | [`ReleaseSchedulesUpdated`](https://frequency-chain.github.io/frequency/pallet_time_release/pallet/enum.Event.html#variant.ReleaseSchedulesUpdated) | 24            |

pallets/time-release/README.md

@@ -55,7 +55,7 @@ benchmarks! {
 		);
 	}
 
-	schedule_transfer {
+	schedule_named_transfer {
 		let schedule = Schedule::<T> {
 			start: 0u32.into(),
 			period: 2u32.into(),
@@ -72,15 +72,14 @@ benchmarks! {
 		let to: T::AccountId = account("to", 1, SEED);
 		let to_lookup = lookup_of_account::<T>(to.clone());
 		let when = 10u32.into();
-
-	}: _(RawOrigin::Signed(from.clone()), to_lookup, schedule.clone(), when)
+	}: _(RawOrigin::Signed(from.clone()),  [1u8; 32], to_lookup, schedule.clone(), when)
 	verify {
 		assert_eq!(
 			T::Currency::balance_on_hold(&HoldReason::TimeReleaseScheduledVesting.into(), &from),
 			schedule.total_amount().unwrap());
 	}
 
-	execute_scheduled_transfer {
+	execute_scheduled_named_transfer {
 		let schedule = Schedule::<T> {
 			start: 0u32.into(),
 			period: 2u32.into(),
@@ -101,7 +100,7 @@ benchmarks! {
 
 		let to_lookup = lookup_of_account::<T>(to.clone());
 		let origin = Origin::<T>::TimeRelease(from.clone());
-	}: _(origin, to_lookup, schedule.clone())
+	}: _(origin, [1u8; 32],to_lookup, schedule.clone())
 	verify {
 		assert_eq!(
 			T::Currency::total_balance(&to),
@@ -165,6 +164,36 @@ benchmarks! {
 		);
 	}
 
+	cancel_scheduled_named_transfer {
+		let i in 1 .. (T::MaxReleaseSchedules::get());
+
+		let mut schedule = Schedule::<T> {
+			start: 0u32.into(),
+			period: 2u32.into(),
+			period_count: 2,
+			per_period: T::MinReleaseTransfer::get(),
+		};
+
+		let from = T::AccountId::decode(&mut TrailingZeroInput::zeroes()).unwrap();
+		set_balance::<T>(&from, schedule.total_amount().unwrap() * BalanceOf::<T>::from(i) + DOLLARS.into());
+
+		let to: T::AccountId = whitelisted_caller();
+		let to_lookup = lookup_of_account::<T>(to.clone());
+
+		for j in 0..i {
+			schedule.start = i.into();
+
+			TimeReleasePallet::<T>::schedule_named_transfer(RawOrigin::Signed(from.clone()).into(), [j as u8 ; 32], to_lookup.clone(), schedule.clone(), 4u32.into())?;
+		}
+
+		let origin = RawOrigin::Signed(from.clone());
+		let schedule_name = [0u8; 32];
+	}: _(origin, schedule_name)
+	verify {
+		ensure!(ScheduleReservedAmounts::<T>::get([0u8 ; 32]).is_none(), "Schedule not canceled");
+	}
+
+
 	impl_benchmark_test_suite!(
 		TimeReleasePallet,
 		crate::mock::ExtBuilder::build(),