pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-01 03:21:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

XCMv4 (#1230)

Browse Source 
# Note for reviewer

Most changes are just syntax changes necessary for the new version.
Most important files should be the ones under the `xcm` folder.

# Description 

Added XCMv4.

## Removed `Multi` prefix
The following types have been renamed:
- MultiLocation -> Location
- MultiAsset -> Asset
- MultiAssets -> Assets
- InteriorMultiLocation -> InteriorLocation
- MultiAssetFilter -> AssetFilter
- VersionedMultiAsset -> VersionedAsset
- WildMultiAsset -> WildAsset
- VersionedMultiLocation -> VersionedLocation

In order to fix a name conflict, the `Assets` in `xcm-executor` were
renamed to `HoldingAssets`, as they represent assets in holding.

## Removed `Abstract` asset id

It was not being used anywhere and this simplifies the code.

Now assets are just constructed as follows:

```rust
let asset: Asset = (AssetId(Location::new(1, Here)), 100u128).into();
```

No need for specifying `Concrete` anymore.

## Outcome is now a named fields struct

Instead of

```rust
pub enum Outcome {
  Complete(Weight),
  Incomplete(Weight, Error),
  Error(Error),
}
```

we now have

```rust
pub enum Outcome {
  Complete { used: Weight },
  Incomplete { used: Weight, error: Error },
  Error { error: Error },
}
```

## Added Reanchorable trait

Now both locations and assets implement this trait, making it easier to
reanchor both.

## New syntax for building locations and junctions

Now junctions are built using the following methods:

```rust
let location = Location {
    parents: 1,
    interior: [Parachain(1000), PalletInstance(50), GeneralIndex(1984)].into()
};
```

or

```rust
let location = Location::new(1, [Parachain(1000), PalletInstance(50), GeneralIndex(1984)]);
```

And they are matched like so:

```rust
match location.unpack() {
  (1, [Parachain(id)]) => ...
  (0, Here) => ...,
  (1, [_]) => ...,
}
```

This syntax is mandatory in v4, and has been also implemented for v2 and
v3 for easier migration.

This was needed to make all sizes smaller.

# TODO
- [x] Scaffold v4
- [x] Port github.com/paritytech/polkadot/pull/7236
- [x] Remove `Multi` prefix
- [x] Remove `Abstract` asset id

---------

Co-authored-by: command-bot <>
Co-authored-by: Keith Yeung <kungfukeith11@gmail.com>
This commit is contained in:
Francisco Aguirre
2024-01-16 19:18:04 +01:00
committed by GitHub
parent ec7bfae00a
commit 8428f678fe
255 changed files with 12425 additions and 6726 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/xcm/xcm-builder/src/tests/version_subscriptions.rs
+76 -34
View File
@@ -25,23 +25,41 @@ fn simple_version_subscriptions_should_work() {
SetAppendix(Xcm(vec![])),
SubscribeVersion { query_id: 42, max_response_weight: Weight::from_parts(5000, 5000) },
]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(20, 20);
let r = XcmExecutor::<TestConfig>::execute_xcm(origin, message, hash, weight_limit);
assert_eq!(r, Outcome::Error(XcmError::Barrier));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Error { error: XcmError::Barrier });
let origin = Parachain(1000);
let message = Xcm::<TestCall>(vec![SubscribeVersion {
query_id: 42,
max_response_weight: Weight::from_parts(5000, 5000),
}]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(10, 10);
let r = XcmExecutor::<TestConfig>::execute_xcm(origin, message.clone(), hash, weight_limit);
assert_eq!(r, Outcome::Error(XcmError::Barrier));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message.clone(),
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Error { error: XcmError::Barrier });
let r = XcmExecutor::<TestConfig>::execute_xcm(Parent, message, hash, weight_limit);
assert_eq!(r, Outcome::Complete(Weight::from_parts(10, 10)));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
Parent,
message,
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Complete { used: Weight::from_parts(10, 10) });
assert_eq!(
SubscriptionRequests::get(),
@@ -53,33 +71,36 @@ fn simple_version_subscriptions_should_work() {
fn version_subscription_instruction_should_work() {
let origin = Parachain(1000);
let message = Xcm::<TestCall>(vec![
DescendOrigin(X1(AccountIndex64 { index: 1, network: None })),
DescendOrigin([AccountIndex64 { index: 1, network: None }].into()),
SubscribeVersion { query_id: 42, max_response_weight: Weight::from_parts(5000, 5000) },
]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(20, 20);
let r = XcmExecutor::<TestConfig>::execute_xcm_in_credit(
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
hash,
&mut hash,
weight_limit,
weight_limit,
);
assert_eq!(r, Outcome::Incomplete(Weight::from_parts(20, 20), XcmError::BadOrigin));
assert_eq!(
r,
Outcome::Incomplete { used: Weight::from_parts(20, 20), error: XcmError::BadOrigin }
);
let message = Xcm::<TestCall>(vec![
SetAppendix(Xcm(vec![])),
SubscribeVersion { query_id: 42, max_response_weight: Weight::from_parts(5000, 5000) },
]);
let hash = fake_message_hash(&message);
let r = XcmExecutor::<TestConfig>::execute_xcm_in_credit(
let mut hash = fake_message_hash(&message);
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
hash,
&mut hash,
weight_limit,
weight_limit,
);
assert_eq!(r, Outcome::Complete(Weight::from_parts(20, 20)));
assert_eq!(r, Outcome::Complete { used: Weight::from_parts(20, 20) });
assert_eq!(
SubscriptionRequests::get(),
@@ -93,20 +114,38 @@ fn simple_version_unsubscriptions_should_work() {
let origin = Parachain(1000);
let message = Xcm::<TestCall>(vec![SetAppendix(Xcm(vec![])), UnsubscribeVersion]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(20, 20);
let r = XcmExecutor::<TestConfig>::execute_xcm(origin, message, hash, weight_limit);
assert_eq!(r, Outcome::Error(XcmError::Barrier));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Error { error: XcmError::Barrier });
let origin = Parachain(1000);
let message = Xcm::<TestCall>(vec![UnsubscribeVersion]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(10, 10);
let r = XcmExecutor::<TestConfig>::execute_xcm(origin, message.clone(), hash, weight_limit);
assert_eq!(r, Outcome::Error(XcmError::Barrier));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message.clone(),
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Error { error: XcmError::Barrier });
let r = XcmExecutor::<TestConfig>::execute_xcm(Parent, message, hash, weight_limit);
assert_eq!(r, Outcome::Complete(Weight::from_parts(10, 10)));
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
Parent,
message,
&mut hash,
weight_limit,
Weight::zero(),
);
assert_eq!(r, Outcome::Complete { used: Weight::from_parts(10, 10) });
assert_eq!(SubscriptionRequests::get(), vec![(Parent.into(), None)]);
assert_eq!(sent_xcm(), vec![]);
@@ -118,31 +157,34 @@ fn version_unsubscription_instruction_should_work() {
// Not allowed to do it when origin has been changed.
let message = Xcm::<TestCall>(vec![
DescendOrigin(X1(AccountIndex64 { index: 1, network: None })),
DescendOrigin([AccountIndex64 { index: 1, network: None }].into()),
UnsubscribeVersion,
]);
let hash = fake_message_hash(&message);
let mut hash = fake_message_hash(&message);
let weight_limit = Weight::from_parts(20, 20);
let r = XcmExecutor::<TestConfig>::execute_xcm_in_credit(
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
hash,
&mut hash,
weight_limit,
weight_limit,
);
assert_eq!(r, Outcome::Incomplete(Weight::from_parts(20, 20), XcmError::BadOrigin));
assert_eq!(
r,
Outcome::Incomplete { used: Weight::from_parts(20, 20), error: XcmError::BadOrigin }
);
// Fine to do it when origin is untouched.
let message = Xcm::<TestCall>(vec![SetAppendix(Xcm(vec![])), UnsubscribeVersion]);
let hash = fake_message_hash(&message);
let r = XcmExecutor::<TestConfig>::execute_xcm_in_credit(
let mut hash = fake_message_hash(&message);
let r = XcmExecutor::<TestConfig>::prepare_and_execute(
origin,
message,
hash,
&mut hash,
weight_limit,
weight_limit,
);
assert_eq!(r, Outcome::Complete(Weight::from_parts(20, 20)));
assert_eq!(r, Outcome::Complete { used: Weight::from_parts(20, 20) });
assert_eq!(SubscriptionRequests::get(), vec![(Parachain(1000).into(), None)]);
assert_eq!(sent_xcm(), vec![]);