Pallet transfers allowlist #1251

thea-leake · 2023-03-13T20:11:36Z

Description

This adds a pallet to handle allowlist for transfers.

It allows users to add an allowance for an account, and if allowances present, then checks against the allowance for the sending account/currrency will be limited to the recievers for which allowances are defined, and allow/blocked at block range.

Fixes #1144

Changes and Descriptions

Adds Transfer Allowlist pallet

Allowlist pallet, and tests added.

Type of change

[ x] New feature (non-breaking change which adds functionality)

How Has This Been Tested?

Pallet unit tests with externalities provided mock env

Checklist:

[x ] I have added Rust doc comments to structs, enums, traits and functions
[x ] I have made corresponding changes to the documentation
[ x] I have performed a self-review of my code
[ x] My changes generate no new warnings
[ x] I have added tests that prove my fix is effective or that my feature works
[x ] New and existing unit tests pass locally with my changes
[ x] I rebased on the latest main branch

mustermeiszer

Looks already neat!

pallets/transfer-allowlist/src/lib.rs

lemunozm

Very neat @thea-leake and very good coverage!

I left a lot of comments, but most of them are minor suggestions & questions. Good job!

pallets/transfer-allowlist/Cargo.toml

pallets/transfer-allowlist/src/lib.rs

lemunozm · 2023-03-21T09:36:44Z

pallets/transfer-allowlist/src/lib.rs

+			match <AccountCurrencyTransferAllowance<T>>::get((&account_id, &currency_id, &receiver))
+			{
+				Some(_) => {
+					T::ReserveCurrency::unreserve(&account_id, T::Deposit::get());


@mustermeiszer @mikiquantum should we use pallet-fees here?

Pallet fees do not support reserve/unreserve, afaik, only one way transfer/burn/etc

But should T::Deposit::get() come from a key? At least we do so for Anchors::pre_commit().

Maybe reserve/unreserve actions need to be added to pallet-fees. 🤔

Ah yes @lemunozm I would definitely define a key in the pallet fees and read the amount from it, that even if for now we do not support the reserve/unreserve logic yet there. That way the UIs can know up front operational costs.
@thea-leake ^^

WIP updating pallet to use fees/feekey. I've got the pallet set up for using fees pallet(config, mocks etc), and additional fee key added. Switching out deposit/reserve logic to use feekey in progress.

👍 Pallet is switched over to use fee key & getting fee val with fees pallet. Also have mock set up to set key val for allowance creation with fees pallet to ensure fees pulled w/ correct key -- FeeKey used in pallet itself is still loosely coupled in allowance pallet.

I left a comment regarding the mock part @thea-leake.

Regarding reserve()/unreserve(), @mikiquantum I've created an issue to add them to pallet-fees: #1282

pallets/transfer-allowlist/src/lib.rs

pallets/transfer-allowlist/src/tests.rs

mikiquantum

Just trying to be curious. 😄 From my limited understanding, it looks good.

libs/types/src/domain_address.rs

mikiquantum · 2023-03-21T21:34:13Z

libs/types/src/locations.rs

+	XCM(H256),
+	/// DomainAddress sending location from connectors
+	Address(DomainAddress),
+	/// Etherium address, for cases where we would have a standalone Eth address


Suggested change

/// Etherium address, for cases where we would have a standalone Eth address

/// Ethereum address, for cases where we would have a standalone Eth address

libs/types/src/locations.rs

mikiquantum · 2023-03-21T21:35:52Z

libs/types/src/locations.rs

+
+impl From<MultiLocation> for Location {
+	fn from(ml: MultiLocation) -> Self {
+		// using hash here as mulitlocation is significantly larger than any other enum type here


Suggested change

// using hash here as mulitlocation is significantly larger than any other enum type here

// using hash here as multilocation is significantly larger than any other enum type here

I, for one, am in favor of having a MulletLocation 😆

mikiquantum · 2023-03-21T21:36:12Z

libs/types/src/locations.rs

+
+impl From<VersionedMultiLocation> for Location {
+	fn from(vml: VersionedMultiLocation) -> Self {
+		// using hash here as mulitlocation is significantly larger than any other enum type here


Suggested change

// using hash here as mulitlocation is significantly larger than any other enum type here

// using hash here as multilocation is significantly larger than any other enum type here

mikiquantum · 2023-03-21T22:19:28Z

pallets/transfer-allowlist/src/lib.rs

+
+	/// Storage item for allowances specified for a sending account, currency type and recieving location
+	#[pallet::storage]
+	#[pallet::getter(fn sender_currency_reciever_allowance)]


Suggested change

#[pallet::getter(fn sender_currency_reciever_allowance)]

#[pallet::getter(fn sender_currency_receiver_allowance)]

👍 fixed, also changed to match storage.

mikiquantum · 2023-03-21T22:19:53Z

pallets/transfer-allowlist/src/lib.rs

+		OptionQuery,
+	>;
+
+	/// Storage item for allowances specified for a sending account, currency type and recieving location


Suggested change

/// Storage item for allowances specified for a sending account, currency type and recieving location

/// Storage item for allowances specified for a sending account, currency type and receiving location

mikiquantum · 2023-03-21T22:26:25Z

pallets/transfer-allowlist/src/lib.rs

+					);
+					Ok(())
+				}
+				Some(_) => Err(DispatchError::Other("Impossible allowance count")),


In which scenario would this branch be possible?

I just had a comment in the same line. This case doesn't belong to the model and can never happen.

I've combined the storage items for delay and count as per @mikiquantum's suggestion, which has removed that case as a possibility with the types so that branch is no longer there. :)
(was not possible to reach before, however types would have accommodated that branch)

pallets/transfer-allowlist/src/lib.rs

mikiquantum · 2023-03-21T22:48:38Z

pallets/transfer-allowlist/src/lib.rs

+	/// This allows us to keep storage map vals to known/bounded sizes.
+	#[pallet::storage]
+	#[pallet::getter(fn sender_currency_restriction_set)]
+	pub type AccountCurrencyTransferRestriction<T: Config> = StorageDoubleMap<


Wouldnt be possible to merge this storage with AccountCurrencyDelay and have a tuple value (u64, BlockNumber). There should be an storage reduction based on the storage prefix+key.

👍 Merged storage items

lemunozm

I had a very clean review feedback, thanks for all your detailed answer to my question/suggestions @thea-leake

pallets/transfer-allowlist/src/lib.rs

libs/types/src/domain_address.rs

NunoAlexandre · 2023-03-22T09:03:18Z

pallets/transfer-allowlist/src/lib.rs

+	pub type DepositBalanceOf<T> = <<T as Config>::ReserveCurrency as Currency<
+		<T as frame_system::Config>::AccountId,
+	>>::Balance;
+
+	//
+	// Storage
+	//
+	pub type AllowanceDetailsOf<T> = AllowanceDetails<<T as frame_system::Config>::BlockNumber>;


FYI We usually place these type aliases at the top, before pub trait Config: frame_system::Config {

NunoAlexandre · 2023-03-22T09:04:26Z

pallets/transfer-allowlist/src/lib.rs

+		pub blocked_at: BlockNumber,
+	}
+
+	impl<BlockNumber> AllowanceDetails<BlockNumber>


We should make this actually implement the Default trait

NunoAlexandre · 2023-03-22T09:06:43Z

pallets/transfer-allowlist/src/lib.rs

+		/// An operation expecting one or more allowances for a sending Account/Currency set, where none present
+		NoAllowancesSet,
+		/// Attempted to create allowance for existing Sending Account, Currency, and Receiver combination
+		ConflictingAllowanceSet,


From the /// comment, I guess this means that this allowance already exists? If so, let's make it consistent with similar error names:

Suggested change

ConflictingAllowanceSet,

DuplicateAllowance,

NunoAlexandre · 2023-03-22T09:07:15Z

pallets/transfer-allowlist/src/lib.rs

+		AllowanceCountArithmeticError,
+		/// No matching allowance for Location/Currency
+		NoMatchingAllowance,
+		/// No matching delay


Can you expand on this error doc?

👍 expanded

NunoAlexandre · 2023-03-22T09:08:52Z

pallets/transfer-allowlist/src/lib.rs

+			let blocked_at = match Self::sender_currency_delay(&account_id, currency_id) {
+				Some(delay) => <frame_system::Pallet<T>>::block_number().saturating_add(delay),
+				_ => <frame_system::Pallet<T>>::block_number(),
+			};


I think this would be a bit easier to read with a .map().unwrap_or() pattern. Up to you 👍

With the merging of the delay and count storage items, there's another option to check/destructure, so I've kept the match, but I agree with how it was before .map().unwrap_or() would be clearer. :)

pallets/transfer-allowlist/src/lib.rs

lemunozm · 2023-03-24T05:38:10Z

pallets/transfer-allowlist/Cargo.toml

 pallet-balances = { git = "https://github.com/paritytech/substrate", default-features = true, branch = "polkadot-v0.9.32" }
+pallet-fees = { path = "../fees" }


You do not need to add pallet-fees/pallet-treasury/pallet-authorship to test this. You can do it much more manageably with the mock in libs/mocks/src/fees.rs

Ah ok, thanks! Yeah that would be a lot more convenient :) I wanted to verify the reserve/unreserve amounts, and verify the pallet was using the FeeKey correctly and ensure that the reserve/unreserve logic was all being handled correctly in here.

I imagine that 👍🏻. Please, if in the process you feel like something in the mock should be changed/improved, share it!

mustermeiszer

This looks really, really good, clean and nice!

But if I understood the code correctly we have 3 logical problems that must be addressed (if I got it right)

add_or_update_allowance_delay MUST only be active after the previously set delay has passed
remove_allowance_delay MUST only be active after the previously set delay has passed
purge_transfer_allowance MUST only be possible of the blocked_at has already passed!

Otherwise, the protection this pallet provides only serves for honest but wrongly inputed receiving addresses. Not for protecting against malicious users who got access to a key.

If the first is enough for us, then we can remove the concept of a delay.

cc: @offerijns for clarification if protection is needed.

mustermeiszer · 2023-03-24T10:01:11Z

libs/types/src/locations.rs

+	/// Test
+	TestLocal(u64),


Can we hide this behind a feature flag? and maybe have a fixed codec index of 255 in order to net mess up tests that rely on decoding?

👍 I've currently got it set to the codec index of 255, and set to only std so as to not be compiled for Wasm. Though if we want to feature gate it a different way I'm ok with that too :).

libs/types/src/locations.rs

pallets/transfer-allowlist/src/lib.rs

mustermeiszer · 2023-03-24T10:10:30Z

pallets/transfer-allowlist/src/lib.rs

+		/// CatchAll for Allowance Count arithmetic errors -- largely for coverage for errors that should be impossible
+		AllowanceCountArithmeticError,


Can we use enum ArithmeticError here instead. It impls Into<DIspatchError>.

👍 using ArithmeticErrorwith ensure ops :)

pallets/transfer-allowlist/src/lib.rs

mustermeiszer · 2023-03-24T10:24:58Z

pallets/transfer-allowlist/src/lib.rs

+			match <AccountCurrencyTransferAllowance<T>>::get((&account_id, &currency_id, &receiver))
+			{
+				Some(_) => {
+					T::ReserveCurrency::unreserve(
+						&account_id,
+						T::Fees::fee_value(T::AllowanceFeeKey::get()),
+					);
+					<AccountCurrencyTransferAllowance<T>>::remove((
+						&account_id,
+						&currency_id,
+						&receiver,
+					));
+					Self::decrement_or_remove_allowance_count(&account_id, &currency_id)?;
+					Self::deposit_event(Event::TransferAllowancePurged {
+						sender_account_id: account_id,
+						currency_id,
+						receiver,
+					});
+					Ok(())
+				}
+				None => Err(DispatchError::from(Error::<T>::NoMatchingAllowance)),
+			}


This should ONLY be possible of the blocked_at has already passed!

👍 updated to ensure blocked_at has already passed.

mustermeiszer · 2023-03-24T10:26:58Z

pallets/transfer-allowlist/src/lib.rs

+			let (count, _) =
+				Self::get_account_currency_restriction_count_delay(&account_id, &currency_id)
+					.unwrap_or((0, Some(0u32.into())));
+			<AccountCurrencyTransferCountDelay<T>>::insert(
+				&account_id,
+				&currency_id,
+				(count, Some(delay)),


Suggested change

let (count, _) =

Self::get_account_currency_restriction_count_delay(&account_id, &currency_id)

.unwrap_or((0, Some(0u32.into())));

<AccountCurrencyTransferCountDelay<T>>::insert(

&account_id,

&currency_id,

(count, Some(delay)),

let (count, delay) =

Self::get_account_currency_restriction_count_delay(&account_id, &currency_id)

.unwrap_or((0, Some(delay)));

<AccountCurrencyTransferCountDelay<T>>::insert(

&account_id,

&currency_id,

(count, Some(delay)),

Well, not sure if actually advantage ^^

mustermeiszer · 2023-03-24T10:28:49Z

pallets/transfer-allowlist/src/lib.rs

+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(0, 1).ref_time())]
+		/// Adds an account/currency delay
+		/// Calling on an existing combination will update the existing delay value
+		pub fn add_or_update_allowance_delay(


The problem here is that

attacker can set delay to zero

add arbitrary off-board address

send tokens

all in one block and batch.

mustermeiszer · 2023-03-24T10:29:28Z

pallets/transfer-allowlist/src/lib.rs

+		#[pallet::call_index(4)]
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(0, 1).ref_time())]
+		/// Removes an existing sending account/currency delay
+		pub fn remove_allowance_delay(


Same goes as above.

mustermeiszer · 2023-03-28T13:40:52Z

pallets/transfer-allowlist/src/lib.rs

+	#[pallet::storage]
+	#[pallet::getter(fn get_account_currency_restriction_count_delay)]
+	pub type AccountCurrencyTransferCountDelay<T: Config> = StorageDoubleMap<
+		_,
+		Twox64Concat,
+		T::AccountId,
+		Twox64Concat,
+		T::CurrencyId,
+		(u64, Option<T::BlockNumber>),
+		OptionQuery,
+	>;


Suggested change

#[pallet::storage]

#[pallet::getter(fn get_account_currency_restriction_count_delay)]

pub type AccountCurrencyTransferCountDelay<T: Config> = StorageDoubleMap<

_,

Twox64Concat,

T::AccountId,

Twox64Concat,

T::CurrencyId,

(u64, Option<T::BlockNumber>),

OptionQuery,

>;

struct Delay<BlockNumber> {

current: BlockNumber,

valid_until: Option<BlockNumber>,

}

#[pallet::storage]

#[pallet::getter(fn get_account_currency_restriction_count_delay)]

pub type AccountCurrencyTransferCountDelay<T: Config> = StorageDoubleMap<

_,

Twox64Concat,

T::AccountId,

Twox64Concat,

T::CurrencyId,

(u64, Option<Delay<T::BlockNumber>>),

OptionQuery,

>;

Maybe we use this, and have the following extrinsics

add_delay

if AccountCurrencyTransferCountDelay is (count, None) → simply add new delay of kind Delay {current: delay, next: None}

update_delay

if AccountCurrencyTransferCountDelay is (count, Some(delay) → only add if the delay.valid_until has passed

purge_delay → is possible to remove storage if count is zero and valid_until has passed

rm_delay → only works

if AccountCurrencyTransferCountDelay is (count, Some(delay) → and valid_until is None and then sets valid_until as now + delay.current

Currently have the pallet updated to use new delay and allow delay purge or modification after current delay has passed--with a set future modifiable extrinsic exposed with the functionality of rm_delay. Looking into refactoring the storage at the moment to clean up the readability of the matching/destructuring (due to the nested options etc).

lemunozm · 2023-04-04T05:58:52Z

pallets/transfer-allowlist/src/mock.rs

+// pallet fees takes a treasury impl as assoc type
+impl pallet_treasury::Config for Runtime {
+	type ApproveOrigin = EnsureSignedBy<Admin, u64>;
+	type Burn = ();
+	type BurnDestination = ();
+	type Currency = Balances;
+	type MaxApprovals = ();
+	type OnSlash = Treasury;
+	type PalletId = TreasuryPalletId;
+	type ProposalBond = ();
+	type ProposalBondMaximum = ();
+	type ProposalBondMinimum = ();
+	type RejectOrigin = EnsureSignedBy<Admin, u64>;
+	type RuntimeEvent = RuntimeEvent;
+	type SpendFunds = ();
+	type SpendOrigin = EnsureSignedBy<Admin, u64>;
+	type SpendPeriod = ();
+	type WeightInfo = ();
+}
+
+parameter_types! {
+	  pub const DefaultFeeValue: Balance = 1;
+}
+
+// pallet fees depends on authorship being configured for runtime.
+// Tight coupling--no assoc type for fees
+impl pallet_authorship::Config for Runtime {
+	type EventHandler = ();
+	type FilterUncle = ();
+	type FindAuthor = ();
+	type UncleGenerations = ();
+}
+
+// used to set/retrieve reserve fee amount
+// so we can surface this to the frontend
+// actual reserve/unreserve handled by reserve currency type
+impl pallet_fees::Config for Runtime {
+	type Currency = Balances;
+	type DefaultFeeValue = DefaultFeeValue;
+	type FeeChangeOrigin = EitherOfDiverse<EnsureRoot<Self::AccountId>, EnsureSignedBy<Admin, u64>>;
+	type FeeKey = FeeKey;
+	type RuntimeEvent = RuntimeEvent;
+	type Treasury = Treasury;
+	type WeightInfo = ();
+}


I would go with mock fees to simplify this before merging it 🤓

All this could be simplified to:

impl pallet_mock_fees::Config for Runtime { type Balance = Balance; type FeeKey = u8; }

You can check pallet-anchors or pallet-nft as an example of how to use it in the tests

Yeah having the mocks would definitely be cleaner, I think it would be best to switch to the mocks after benchmarking is done so that the weight/time from those dependencies are taken into account (though in this case it shouldn't really affect the benchmarks much if at all), then switch to use the mocks so the tests aren't coupled with the other pallet dependencies/changes.

I think it would be best to switch to the mocks after benchmarking is done so that the weight/time from those dependencies are taken into account

Mocks will run only under test. The real benchmarks that generates the weights will run without test and will use the correct implementations coming from the runtime. So there is no issue with benchmark times using trait mocks.

Anyway, no hurry!

pallets/transfer-allowlist/src/lib.rs

mustermeiszer

If clauses are checking the wrong way for times. Otherwise changes look good!

mustermeiszer · 2023-04-04T07:15:59Z

pallets/transfer-allowlist/src/lib.rs

+
+	#[pallet::pallet]
+	#[pallet::generate_store(pub(super) trait Store)]
+	pub struct Pallet<T>(_);


No requirement. But might be good to get started with using this always.

Suggested change

#[pallet::pallet]

#[pallet::generate_store(pub(super) trait Store)]

pub struct Pallet<T>(_);

/// The current storage version.

const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);

#[pallet::pallet]

#[pallet::generate_store(pub(super) trait Store)]

#[pallet::storage_version(STORAGE_VERSION)]

pub struct Pallet<T>(_);

mustermeiszer · 2023-04-04T08:03:20Z

pallets/transfer-allowlist/src/lib.rs

+
+		#[pallet::call_index(4)]
+		#[pallet::weight(10_000 + T::DbWeight::get().reads_writes(0, 1).ref_time())]
+		/// Updates an allowance delay, only callable is the delay has been set to allow future modifications and


Suggested change

/// Updates an allowance delay, only callable is the delay has been set to allow future modifications and

/// Updates an allowance delay, only callable if the delay has been set to allow future modifications and

pallets/transfer-allowlist/src/lib.rs

mustermeiszer · 2023-04-04T08:58:13Z

pallets/transfer-allowlist/src/lib.rs

+				Some(AllowanceMetadata {
+					modifiable_at: Some(modifiable_at),
+					..
+				}) if modifiable_at > current_block => Err(DispatchError::from(Error::<T>::DelayUnmodifiable)),


Must be

if current_block < modifiable_at

mustermeiszer · 2023-04-04T08:58:41Z

pallets/transfer-allowlist/src/lib.rs

+		pub fn set_allowance_delay_future_modifiable(
+			origin: OriginFor<T>,
+			currency_id: T::CurrencyId,
+		) -> DispatchResult {
+			let account_id = ensure_signed(origin)?;
+			let current_block = <frame_system::Pallet<T>>::block_number();
+			match Self::get_account_currency_restriction_count_delay(&account_id, &currency_id) {
+				None => Err(DispatchError::from(Error::<T>::NoMatchingDelay)),
+				Some(AllowanceMetadata {
+					current_delay: None,
+					..
+				}) => Err(DispatchError::from(Error::<T>::NoMatchingDelay)),
+				Some(AllowanceMetadata {
+					modifiable_at: Some(modifiable_at),
+					..
+				}) if modifiable_at > current_block => Err(DispatchError::from(Error::<T>::DelayUnmodifiable)),
+				Some(
+					metadata @ AllowanceMetadata {
+						current_delay: Some(current_delay),
+						..
+					},
+				) => {
+					let modifiable_at = current_block.ensure_add(current_delay)?;
+					<AccountCurrencyTransferCountDelay<T>>::insert(
+						&account_id,
+						&currency_id,
+						AllowanceMetadata {
+							modifiable_at: Some(modifiable_at),
+							..metadata
+						},
+					);
+					Self::deposit_event(Event::TransferAllowanceDelayFutureModifiable {
+						sender_account_id: account_id,
+						currency_id,
+						modifiable_at,
+					});
+					Ok(())
+				}
+			}
+		}


Change as talked about (see slack for requirements)

mustermeiszer · 2023-04-04T08:59:09Z

pallets/transfer-allowlist/src/lib.rs

+					allowance_count: 0,
+					modifiable_at: Some(modifiable_at),
+					..
+				}) if modifiable_at <= current_block => {


Must be

if current_block < modifiable_at

mustermeiszer

That looks really nice! Thanks for closing so quickly. I would say lets merge it.

removed old error enum items.

mustermeiszer

Re-approve

mustermeiszer reviewed Mar 15, 2023

View reviewed changes

lemunozm reviewed Mar 16, 2023

View reviewed changes

pallets/transfer-allowlist/src/lib.rs Outdated Show resolved Hide resolved

thea-leake force-pushed the pallet_transfers_allowlist branch from 9a4c510 to 6d77aa5 Compare March 20, 2023 18:27

thea-leake changed the title ~~WIP Pallet transfers allowlist~~ Pallet transfers allowlist Mar 20, 2023

thea-leake marked this pull request as ready for review March 20, 2023 20:45

This was referenced Mar 20, 2023

Pallet-Transfer-Allowlist #1144

Closed

Pallet-Transfer-Allowlist: Tests #1145

Open

thea-leake requested review from lemunozm, mustermeiszer, NunoAlexandre, branan, wischli and mikiquantum March 20, 2023 20:58

lemunozm reviewed Mar 21, 2023

View reviewed changes

thea-leake force-pushed the pallet_transfers_allowlist branch from a84d291 to 5a457f6 Compare March 21, 2023 19:34

mikiquantum reviewed Mar 21, 2023

View reviewed changes

lemunozm reviewed Mar 22, 2023

View reviewed changes

pallets/transfer-allowlist/src/lib.rs Outdated Show resolved Hide resolved

NunoAlexandre reviewed Mar 22, 2023

View reviewed changes

thea-leake force-pushed the pallet_transfers_allowlist branch from a81a800 to 348e534 Compare March 22, 2023 19:24

thea-leake commented Mar 23, 2023

View reviewed changes

pallets/transfer-allowlist/src/lib.rs Show resolved Hide resolved

lemunozm reviewed Mar 24, 2023

View reviewed changes

mustermeiszer requested changes Mar 24, 2023

View reviewed changes

thea-leake force-pushed the pallet_transfers_allowlist branch from f533eba to a5a5595 Compare March 27, 2023 20:58

mustermeiszer reviewed Mar 28, 2023

View reviewed changes

lemunozm reviewed Apr 4, 2023

View reviewed changes

mustermeiszer requested changes Apr 4, 2023

View reviewed changes

thea-leake force-pushed the pallet_transfers_allowlist branch from b9f0f75 to 03658d9 Compare April 4, 2023 17:37

mustermeiszer previously approved these changes Apr 4, 2023

View reviewed changes

thea-leake dismissed mustermeiszer’s stale review via 28b7362 April 5, 2023 09:58

thea-leake force-pushed the pallet_transfers_allowlist branch from 03658d9 to 28b7362 Compare April 5, 2023 09:58

thea-leake added 24 commits April 11, 2023 10:33

Added docline comment to Location assoc type for pallet config

d149a6e

Updated mock runtime to include fees

3e77789

FeeKey setup for AllowanceTransfers

683e157

Have extrinsics mock env setting new fee key val correctly

5b4c716

Finished switching to fees for deposit reserve val

e4735a0

Added doc lines to new fee types, switched checked add to ensure, and

b6c3f8f

removed old error enum items.

Switched test account location to std only, removed standalone eth addr

f99e78e

Moved location tests to module in location file

94299e2

Updated allowance purging to ensure blocked at has passed.

47cc6a3

Updated nix hash, added test for local test conversion also back in

4c93e3b

update delay to have delay in modification

208414e

Add handling of set delay future modifiable

bcf5d06

update tests for delay changes

e48a57f

continue delay test fixes

5303d05

Add tests for set delay modifiable and purge

2ecf13d

Fix purge modifiable check, add purge delay check

b329adf

Refactor allowance delay and count -> combined struct

3c83d71

Update tests for delay & count struct refactor

1f5b250

Fix clippy warnings

185b486

Fix modifiable_t conditions, set_modifiable->toggle, update naming

94c6d69

Add tests for modify delay

036ae75

Switch TransferAllowance return to DispatchResult

fe74f4b

Update nix hash

3e0e297

Update nix hash

dfaf3f5

thea-leake dismissed mustermeiszer’s stale review via dfaf3f5 April 11, 2023 09:52

thea-leake force-pushed the pallet_transfers_allowlist branch from 3878747 to dfaf3f5 Compare April 11, 2023 09:52

thea-leake added 2 commits April 11, 2023 12:05

Fix types Cargo fmt

14b7687

Fix new clippy warnings

cd57459

mustermeiszer approved these changes Apr 11, 2023

View reviewed changes

thea-leake merged commit 6665505 into centrifuge:main Apr 11, 2023
11 checks passed

	/// Etherium address, for cases where we would have a standalone Eth address
	/// Ethereum address, for cases where we would have a standalone Eth address

	// using hash here as mulitlocation is significantly larger than any other enum type here
	// using hash here as multilocation is significantly larger than any other enum type here

	#[pallet::getter(fn sender_currency_reciever_allowance)]
	#[pallet::getter(fn sender_currency_receiver_allowance)]

	/// Storage item for allowances specified for a sending account, currency type and recieving location
	/// Storage item for allowances specified for a sending account, currency type and receiving location

		pallet-balances = { git = "https://github.com/paritytech/substrate", default-features = true, branch = "polkadot-v0.9.32" }
		pallet-fees = { path = "../fees" }

		/// CatchAll for Allowance Count arithmetic errors -- largely for coverage for errors that should be impossible
		AllowanceCountArithmeticError,

	/// Updates an allowance delay, only callable is the delay has been set to allow future modifications and
	/// Updates an allowance delay, only callable if the delay has been set to allow future modifications and

Pallet transfers allowlist #1251

Pallet transfers allowlist #1251

Conversation

thea-leake commented Mar 13, 2023 • edited

Description

Changes and Descriptions

Adds Transfer Allowlist pallet

Type of change

How Has This Been Tested?

Checklist:

mustermeiszer left a comment

Choose a reason for hiding this comment

lemunozm left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mikiquantum Mar 22, 2023 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mikiquantum left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

lemunozm left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mustermeiszer left a comment • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mustermeiszer Mar 28, 2023 • edited

Choose a reason for hiding this comment

mustermeiszer Mar 28, 2023 • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mustermeiszer left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

thea-leake commented Mar 13, 2023 •

edited

mikiquantum Mar 22, 2023 •

edited

mustermeiszer left a comment •

edited

mustermeiszer Mar 28, 2023 •

edited

mustermeiszer Mar 28, 2023 •

edited