diff --git a/.config/lychee.toml b/.config/lychee.toml
index 1de9fcd559dd9ea14fb603b7740efebcb893ed93..b1f08de33340999d52114ed8c6b5fcd6604662fa 100644
--- a/.config/lychee.toml
+++ b/.config/lychee.toml
@@ -18,7 +18,10 @@ accept = [
"429",
]
-exclude_path = ["./target"]
+exclude_path = [
+ "./prdoc",
+ "./target",
+]
exclude = [
# Place holders (no need to fix these):
@@ -32,7 +35,6 @@ exclude = [
"https://github.com/paritytech/polkadot-sdk/substrate/frame/timestamp",
"https://github.com/paritytech/substrate/frame/fast-unstake",
"https://github.com/zkcrypto/bls12_381/blob/e224ad4ea1babfc582ccd751c2bf128611d10936/src/test-data/mod.rs",
- "https://polkadot-try-runtime-node.parity-chains.parity.io/",
"https://polkadot.network/the-path-of-a-parachain-block/",
"https://research.web3.foundation/en/latest/polkadot/NPoS/3.%20Balancing.html",
"https://research.web3.foundation/en/latest/polkadot/Token%20Economics.html#inflation-model",
@@ -41,6 +43,7 @@ exclude = [
"https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html#inflation-model",
"https://research.web3.foundation/en/latest/polkadot/slashing/npos.html",
"https://rpc.polkadot.io/",
+ "https://try-runtime.polkadot.io/",
"https://w3f.github.io/parachain-implementers-guide/node/approval/approval-distribution.html",
"https://w3f.github.io/parachain-implementers-guide/node/index.html",
"https://w3f.github.io/parachain-implementers-guide/protocol-chain-selection.html",
diff --git a/.config/zepter.yaml b/.config/zepter.yaml
index 9b3bd9d618c14e41f1dbf420aff3fee1677e2830..7a67ba2695cf697c886b31520431ea0ee33e14c9 100644
--- a/.config/zepter.yaml
+++ b/.config/zepter.yaml
@@ -27,7 +27,7 @@ workflows:
]
# The umbrella crate uses more features, so we to check those too:
check_umbrella:
- - [ $check.0, '--features=serde,experimental,with-tracing,tuples-96,with-tracing', '-p=polkadot-sdk' ]
+ - [ $check.0, '--features=serde,experimental,riscv,runtime,with-tracing,tuples-96,with-tracing', '-p=polkadot-sdk' ]
# Same as `check_*`, but with the `--fix` flag.
default:
- [ $check.0, '--fix' ]
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 4fc5b97caae0735058337c8b23e4ca7471761d24..d13add97d419dca273fb1f0604f4da7ecee6cd5b 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -64,7 +64,8 @@
/substrate/primitives/merkle-mountain-range/ @acatangiu
# Contracts
-/substrate/frame/contracts/ @athei @paritytech/docs-audit
+/substrate/frame/contracts/ @paritytech/smart-contracts @paritytech/docs-audit
+/substrate/frame/revive/ @paritytech/smart-contracts @paritytech/docs-audit
# NPoS and election
/substrate/frame/election-provider-multi-phase/ @paritytech/staking-core @paritytech/docs-audit
diff --git a/.github/actions/build-push-image/action.yml b/.github/actions/build-push-image/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fead9cfe336933dbde9a936e49b44fe1cf1396ed
--- /dev/null
+++ b/.github/actions/build-push-image/action.yml
@@ -0,0 +1,47 @@
+name: 'build and push image'
+inputs:
+ dockerfile:
+ description: "dockerfile to build"
+ required: true
+ image-name:
+ description: ""
+ required: true
+outputs:
+ branch:
+ description: 'Branch name for the PR'
+ value: ${{ steps.branch.outputs.branch }}
+
+
+runs:
+ using: "composite"
+ steps:
+
+ # gcloud
+ # https://github.com/paritytech/ci_cd/wiki/GitHub:-Push-Docker-image-to-GCP-Registry
+ - name: "Set up Cloud SDK"
+ uses: "google-github-actions/setup-gcloud@v2"
+ - name: "gcloud info"
+ shell: bash
+ run: "gcloud info"
+ - name: "Auth in gcloud registry"
+ shell: bash
+ run: "gcloud auth configure-docker europe-docker.pkg.dev --quiet"
+
+ - name: build
+ shell: bash
+ env:
+ ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.105"
+ run: |
+ export BRANCH_NAME=${{ github.head_ref || github.ref_name }}
+ export DOCKER_IMAGES_VERSION=${BRANCH_NAME/\//-}
+ if [[ ${{ github.event_name }} == "merge_group" ]]; then export DOCKER_IMAGES_VERSION="${GITHUB_SHA::8}"; fi
+ docker build \
+ --build-arg VCS_REF="${GITHUB_SHA}" \
+ --build-arg BUILD_DATE="$(date -u '+%Y-%m-%dT%H:%M:%SZ')" \
+ --build-arg IMAGE_NAME="${{ inputs.image-name }}" \
+ --build-arg ZOMBIENET_IMAGE="${ZOMBIENET_IMAGE}" \
+ -t "${{ inputs.image-name }}:$DOCKER_IMAGES_VERSION" \
+ -f ${{ inputs.dockerfile }} \
+ .
+ docker push "${{ inputs.image-name }}:$DOCKER_IMAGES_VERSION"
+
diff --git a/.github/actions/cargo-check-runtimes/action.yml b/.github/actions/cargo-check-runtimes/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..869f17661e4a23e3c07256a8f59303c09fec7d9b
--- /dev/null
+++ b/.github/actions/cargo-check-runtimes/action.yml
@@ -0,0 +1,22 @@
+name: 'cargo check runtimes'
+description: 'Runs `cargo check` for every directory in provided root.'
+inputs:
+ root:
+ description: "Root directory. Expected to contain several cargo packages inside."
+ required: true
+runs:
+ using: "composite"
+ steps:
+ - name: Check
+ shell: bash
+ run: |
+ mkdir -p ~/.forklift
+ cp .forklift/config.toml ~/.forklift/config.toml
+ cd ${{ inputs.root }}
+ for directory in $(echo */); do
+ echo "_____Running cargo check for ${directory} ______";
+ cd ${directory};
+ pwd;
+ SKIP_WASM_BUILD=1 forklift cargo check --locked;
+ cd ..;
+ done
diff --git a/.github/codecov.yml b/.github/codecov.yml
index ceceb9e63654ce83c942571dea79cae29f15d851..b237c9fe6b044492349aa2f94c860f5e940d0589 100644
--- a/.github/codecov.yml
+++ b/.github/codecov.yml
@@ -6,4 +6,10 @@ coverage:
project:
default:
target: 1.0
- threshold: 2.0
\ No newline at end of file
+ threshold: 2.0
+
+comment:
+ behavior: new
+
+fixes:
+ - "/__w/polkadot-sdk/polkadot-sdk/::"
\ No newline at end of file
diff --git a/.github/command-screnshot.png b/.github/command-screnshot.png
deleted file mode 100644
index 1451fabca8b975534778e8321facd261e3b803fb..0000000000000000000000000000000000000000
Binary files a/.github/command-screnshot.png and /dev/null differ
diff --git a/.github/commands-readme.md b/.github/commands-readme.md
deleted file mode 100644
index bf0e9e5ed20bb3085e6bbe3e59079372121167b1..0000000000000000000000000000000000000000
--- a/.github/commands-readme.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# Running commands
-
-Command bot has been migrated, it is no longer a comment parser and now it is a GitHub action that works as a [`workflow_dispatch`](https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflow_dispatch) event.
-
-## How to run an action
-
-To run an action, you need to go to the [_actions tab_](https://github.com/paritytech/polkadot-sdk/actions) and pick the one you desire to run.
-
-The current available command actions are:
-
-- [Command FMT](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-fmt.yml)
-- [Command Update UI](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-update-ui.yml)
-- [Command Bench](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench.yml)
-- [Command Bench All](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench-all.yml)
-- [Command Bench Overhead](https://github.com/paritytech/polkadot-sdk/actions/workflows/command-bench-overhead.yml)
-
-You need to select the action, and click on the dropdown that says: `Run workflow`. It is located in the upper right.
-
-If this dropdown is not visible, you may not have permission to run the action. Contact IT for help.
-
-
-
-Each command will have the same two required values, but it could have more.
-
-GitHub's official documentation: [Manually running a workflow](https://docs.github.com/en/actions/using-workflows/manually-running-a-workflow)
-
-### Number of the Pull Request
-
-The number of the pull request. Required so the action can fetch the correct branch and comment if it fails.
-
-## Action configurations
-
-### Bench
-
-Runs `benchmark pallet` or `benchmark overhead` against your PR and commits back updated weights.
-
-Posible combinations based on the `benchmark` dropdown.
-
-- `substrate-pallet`: Pallet Benchmark for Substrate for specific pallet
- - Requires `Subcommand` to be `pallet`
- - Requires `Runtime` to be `dev`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Target Directory` to be `substrate`
-- `polkadot-pallet`: Pallet Benchmark for Polkadot for specific pallet
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `rococo`
- - `westend`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Target Directory` to be `polkadot`
-- `cumulus-assets`: Pallet Benchmark for Cumulus assets
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `asset-hub-westend`
- - `asset-hub-rococo`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `assets`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-collectives`: Pallet Benchmark for Cumulus collectives
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be `collectives-westend`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `collectives`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-coretime`: Pallet Benchmark for Cumulus coretime
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `coretime-rococo`
- - `coretime-westend`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `coretime`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-bridge-hubs`: Pallet Benchmark for Cumulus bridge-hubs
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `bridge-hub-rococo`
- - `bridge-hub-westend`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `bridge-hub`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-contracts`: Pallet Benchmark for Cumulus contracts
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one `contracts-rococo`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `contracts`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-glutton`: Pallet Benchmark for Cumulus glutton
- - Requires `Subcommand` to be `pallet`
- - Requires `Runtime` to be one of the following:
- - `glutton-westend`
- - `glutton-westend-dev-1300`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `glutton`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-starters`: Pallet Benchmark for Cumulus starters
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `seedling`
- - `shell`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `starters`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-people`: Pallet Benchmark for Cumulus people
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `people-westend`
- - `people-rococo`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `people`
- - Requires `Target Directory` to be `cumulus`
-- `cumulus-testing`: Pallet Benchmark for Cumulus testing
- - Requires `Subcommand` to be one of the following:
- - `pallet`
- - `xcm`
- - Requires `Runtime` to be one of the following:
- - `penpal`
- - `rococo-parachain`
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
- - Requires `Runtime Dir` to be `testing`
- - Requires `Target Directory` to be `cumulus`
-
-### Bench-all
-
-This is a wrapper to run `bench` for all pallets.
-
-Posible combinations based on the `benchmark` dropdown.
-
-- `pallet`: Benchmark for Substrate/Polkadot/Cumulus/Trappist for specific pallet
- - Requires field `Pallet` to have an input that applies to `^([a-z_]+)([:]{2}[a-z_]+)?$`
-- `substrate`: Pallet + Overhead + Machine Benchmark for Substrate for all pallets
- - Requires `Target Directory` to be `substrate`
-- `polkadot`: Pallet + Overhead Benchmark for Polkadot
- - Requires `Runtime` to be one of the following:
- - `rococo`
- - `westend`
- - Requires `Target Directory` to be `polkadot`
-- `cumulus`: Pallet Benchmark for Cumulus
- - Requires `Runtime` to be one of the following:
- - `rococo`
- - `westend`
- - `asset-hub-kusama`
- - `asset-hub-polkadot`
- - `asset-hub-rococo`
- - `asset-hub-westend`
- - `bridge-hub-kusama`
- - `bridge-hub-polkadot`
- - `bridge-hub-rococo`
- - `bridge-hub-westend`
- - `collectives-polkadot`
- - `collectives-westend`
- - `coretime-rococo`
- - `coretime-westend`
- - `contracts-rococo`
- - `glutton-kusama`
- - `glutton-westend`
- - `people-rococo`
- - `people-westend`
- - Requires `Target Directory` to be `cumulus`
-
-### Bench-overhead
-
-Run benchmarks overhead and commit back results to PR.
-
-Posible combinations based on the `benchmark` dropdown.
-
-- `default`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
- - Requires `Runtime` to be one of the following:
- - `rococo`
- - `westend`
- - Requires `Target directory` to be `polkadot`
-- `substrate`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
- - Requires `Target directory` to be `substrate`
-- `cumulus`: Runs `benchmark overhead` and commits back to PR the updated `extrinsic_weights.rs` files
- - Requires `Runtime` to be one of the following:
- - `asset-hub-rococo`
- - `asset-hub-westend`
- - Requires `Target directory` to be `cumulus`
-
-## How to modify an action
-
-If you want to modify an action and test it, you can do by simply pushing your changes and then selecting your branch in the `Use worflow from` option.
-
-This will use a file from a specified branch.
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 3277a6e4607a74b2b59e24fce951e68c8703fcfc..12f81b04d3a1228d3f4533c8e3d34d6935df51c6 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -5,13 +5,17 @@ updates:
directory: '/'
labels: ["A1-insubstantial", "R0-silent"]
schedule:
- interval: daily
+ interval: weekly
+ groups:
+ ci_dependencies:
+ patterns:
+ - "*"
# Update Rust dependencies:
- package-ecosystem: "cargo"
directory: "/"
labels: ["A1-insubstantial", "R0-silent"]
schedule:
- interval: "daily"
+ interval: "weekly"
groups:
# We assume these crates to be semver abiding and can therefore group them together.
known_good_semver:
diff --git a/.github/env b/.github/env
index 162ce8af7c0ddbc1534b7d1ffb09cff4be012fc7..2e4d5b48100dfb3e976270efd155843e907687a8 100644
--- a/.github/env
+++ b/.github/env
@@ -1 +1 @@
-IMAGE="docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v20240408"
\ No newline at end of file
+IMAGE="docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v202407161507"
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 120000
index 0000000000000000000000000000000000000000..7b6b3498755f586abec9256cbf8f455c16928ffd
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1 @@
+../docs/contributor/PULL_REQUEST_TEMPLATE.md
\ No newline at end of file
diff --git a/.github/review-bot.yml b/.github/review-bot.yml
index adbc480c6ba1a69e8cdd112af4be378849d26315..c2080142f506a6b594bf96521f383404d7337c9d 100644
--- a/.github/review-bot.yml
+++ b/.github/review-bot.yml
@@ -29,7 +29,7 @@ rules:
# excluding files from 'Runtime files' and 'CI files' rules
exclude:
- ^cumulus/parachains/common/src/[^/]+\.rs$
- - ^substrate/frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|election|nomination-pools/.*|staking/.*|aura/.*))
+ - ^substrate/frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|revive/.*|election|nomination-pools/.*|staking/.*|aura/.*))
- ^\.gitlab-ci\.yml
- ^docker/.*
- ^\.github/.*
@@ -56,7 +56,7 @@ rules:
- name: FRAME coders substrate
condition:
include:
- - ^substrate/frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|election|nomination-pools/.*|staking/.*|aura/.*))
+ - ^substrate/frame/(?!.*(nfts/.*|uniques/.*|babe/.*|grandpa/.*|beefy|merkle-mountain-range/.*|contracts/.*|revive/.*|election|nomination-pools/.*|staking/.*|aura/.*))
type: "and"
reviewers:
- minApprovals: 2
@@ -66,6 +66,17 @@ rules:
teams:
- frame-coders
+ # Smart Contracts
+ - name: Smart Contracts
+ type: basic
+ condition:
+ include:
+ - ^substrate/frame/contracts/.*
+ - ^substrate/frame/revive/.*
+ minApprovals: 2
+ teams:
+ - smart-contracts
+
# Protection of THIS file
- name: Review Bot
countAuthor: true
diff --git a/.gitlab/check-each-crate.py b/.github/scripts/check-each-crate.py
similarity index 81%
rename from .gitlab/check-each-crate.py
rename to .github/scripts/check-each-crate.py
index 9b654f8071ac7237fe9c7c943540e8e020cebd6e..7a53e812ddfc73ad59943b5fc62a4b8757f29524 100755
--- a/.gitlab/check-each-crate.py
+++ b/.github/scripts/check-each-crate.py
@@ -9,6 +9,7 @@
#
# - `target_group`: Integer starting from 1, the group this script should execute.
# - `groups_total`: Integer starting from 1, total number of groups.
+# - `disable_forklift`: Boolean, whether to disable forklift or not.
import subprocess, sys
@@ -31,6 +32,9 @@ crates.sort()
target_group = int(sys.argv[1]) - 1
groups_total = int(sys.argv[2])
+disable_forklift = bool(sys.argv[3] if len(sys.argv) > 3 else False)
+
+print(f"Target group: {target_group}, Total groups: {groups_total}, Disable forklift: {disable_forklift}", file=sys.stderr)
if len(crates) == 0:
print("No crates detected!", file=sys.stderr)
@@ -55,7 +59,11 @@ for i in range(0, crates_per_group + overflow_crates):
print(f"Checking {crates[crate][0]}", file=sys.stderr)
- res = subprocess.run(["forklift", "cargo", "check", "--locked"], cwd = crates[crate][1])
+ cmd = ["cargo", "check", "--locked"]
+
+ cmd.insert(0, 'forklift') if not disable_forklift else None
+
+ res = subprocess.run(cmd, cwd = crates[crate][1])
if res.returncode != 0:
sys.exit(1)
diff --git a/.github/scripts/cmd/_help.py b/.github/scripts/cmd/_help.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ad49dad8461e38a7d4bfe1d54f408071d7ae509
--- /dev/null
+++ b/.github/scripts/cmd/_help.py
@@ -0,0 +1,26 @@
+import argparse
+
+"""
+
+Custom help action for argparse, it prints the help message for the main parser and all subparsers.
+
+"""
+
+
+class _HelpAction(argparse._HelpAction):
+ def __call__(self, parser, namespace, values, option_string=None):
+ parser.print_help()
+
+ # retrieve subparsers from parser
+ subparsers_actions = [
+ action for action in parser._actions
+ if isinstance(action, argparse._SubParsersAction)]
+ # there will probably only be one subparser_action,
+ # but better save than sorry
+ for subparsers_action in subparsers_actions:
+ # get all subparsers and print help
+ for choice, subparser in subparsers_action.choices.items():
+ print("\n### Command '{}'".format(choice))
+ print(subparser.format_help())
+
+ parser.exit()
diff --git a/.github/scripts/cmd/cmd.py b/.github/scripts/cmd/cmd.py
new file mode 100755
index 0000000000000000000000000000000000000000..f7dd88df4bda42551b339c3492a29028511c3550
--- /dev/null
+++ b/.github/scripts/cmd/cmd.py
@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import json
+import argparse
+import _help
+import importlib.util
+
+_HelpAction = _help._HelpAction
+
+f = open('.github/workflows/runtimes-matrix.json', 'r')
+runtimesMatrix = json.load(f)
+
+runtimeNames = list(map(lambda x: x['name'], runtimesMatrix))
+
+common_args = {
+ '--continue-on-fail': {"action": "store_true", "help": "Won't exit(1) on failed command and continue with next steps. "},
+ '--quiet': {"action": "store_true", "help": "Won't print start/end/failed messages in PR"},
+ '--clean': {"action": "store_true", "help": "Clean up the previous bot's & author's comments in PR"},
+ '--image': {"help": "Override docker image '--image docker.io/paritytech/ci-unified:latest'"},
+}
+
+parser = argparse.ArgumentParser(prog="/cmd ", description='A command runner for polkadot-sdk repo', add_help=False)
+parser.add_argument('--help', action=_HelpAction, help='help for help if you need some help') # help for help
+for arg, config in common_args.items():
+ parser.add_argument(arg, **config)
+
+subparsers = parser.add_subparsers(help='a command to run', dest='command')
+
+"""
+BENCH
+"""
+
+bench_example = '''**Examples**:
+ Runs all benchmarks
+ %(prog)s
+
+ Runs benchmarks for pallet_balances and pallet_multisig for all runtimes which have these pallets. **--quiet** makes it to output nothing to PR but reactions
+ %(prog)s --pallet pallet_balances pallet_xcm_benchmarks::generic --quiet
+
+ Runs bench for all pallets for westend runtime and continues even if some benchmarks fail
+ %(prog)s --runtime westend --continue-on-fail
+
+ Does not output anything and cleans up the previous bot's & author command triggering comments in PR
+ %(prog)s --runtime westend rococo --pallet pallet_balances pallet_multisig --quiet --clean
+'''
+
+parser_bench = subparsers.add_parser('bench', help='Runs benchmarks', epilog=bench_example, formatter_class=argparse.RawDescriptionHelpFormatter)
+
+for arg, config in common_args.items():
+ parser_bench.add_argument(arg, **config)
+
+parser_bench.add_argument('--runtime', help='Runtime(s) space separated', choices=runtimeNames, nargs='*', default=runtimeNames)
+parser_bench.add_argument('--pallet', help='Pallet(s) space separated', nargs='*', default=[])
+
+"""
+FMT
+"""
+parser_fmt = subparsers.add_parser('fmt', help='Formats code (cargo +nightly-VERSION fmt) and configs (taplo format)')
+for arg, config in common_args.items():
+ parser_fmt.add_argument(arg, **config)
+
+"""
+Update UI
+"""
+parser_ui = subparsers.add_parser('update-ui', help='Updates UI tests')
+for arg, config in common_args.items():
+ parser_ui.add_argument(arg, **config)
+
+"""
+PRDOC
+"""
+# Import generate-prdoc.py dynamically
+spec = importlib.util.spec_from_file_location("generate_prdoc", ".github/scripts/generate-prdoc.py")
+generate_prdoc = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(generate_prdoc)
+
+parser_prdoc = subparsers.add_parser('prdoc', help='Generates PR documentation')
+generate_prdoc.setup_parser(parser_prdoc)
+
+def main():
+ global args, unknown, runtimesMatrix
+ args, unknown = parser.parse_known_args()
+
+ print(f'args: {args}')
+
+ if args.command == 'bench':
+ runtime_pallets_map = {}
+ failed_benchmarks = {}
+ successful_benchmarks = {}
+
+ profile = "release"
+
+ print(f'Provided runtimes: {args.runtime}')
+ # convert to mapped dict
+ runtimesMatrix = list(filter(lambda x: x['name'] in args.runtime, runtimesMatrix))
+ runtimesMatrix = {x['name']: x for x in runtimesMatrix}
+ print(f'Filtered out runtimes: {runtimesMatrix}')
+
+ # loop over remaining runtimes to collect available pallets
+ for runtime in runtimesMatrix.values():
+ os.system(f"forklift cargo build -p {runtime['package']} --profile {profile} --features runtime-benchmarks")
+ print(f'-- listing pallets for benchmark for {runtime["name"]}')
+ wasm_file = f"target/{profile}/wbuild/{runtime['package']}/{runtime['package'].replace('-', '_')}.wasm"
+ output = os.popen(
+ f"frame-omni-bencher v1 benchmark pallet --no-csv-header --no-storage-info --no-min-squares --no-median-slopes --all --list --runtime={wasm_file}").read()
+ raw_pallets = output.strip().split('\n')
+
+ all_pallets = set()
+ for pallet in raw_pallets:
+ if pallet:
+ all_pallets.add(pallet.split(',')[0].strip())
+
+ pallets = list(all_pallets)
+ print(f'Pallets in {runtime["name"]}: {pallets}')
+ runtime_pallets_map[runtime['name']] = pallets
+
+ print(f'\n')
+
+ # filter out only the specified pallets from collected runtimes/pallets
+ if args.pallet:
+ print(f'Pallets: {args.pallet}')
+ new_pallets_map = {}
+ # keep only specified pallets if they exist in the runtime
+ for runtime in runtime_pallets_map:
+ if set(args.pallet).issubset(set(runtime_pallets_map[runtime])):
+ new_pallets_map[runtime] = args.pallet
+
+ runtime_pallets_map = new_pallets_map
+
+ print(f'Filtered out runtimes & pallets: {runtime_pallets_map}\n')
+
+ if not runtime_pallets_map:
+ if args.pallet and not args.runtime:
+ print(f"No pallets {args.pallet} found in any runtime")
+ elif args.runtime and not args.pallet:
+ print(f"{args.runtime} runtime does not have any pallets")
+ elif args.runtime and args.pallet:
+ print(f"No pallets {args.pallet} found in {args.runtime}")
+ else:
+ print('No runtimes found')
+ sys.exit(1)
+
+ for runtime in runtime_pallets_map:
+ for pallet in runtime_pallets_map[runtime]:
+ config = runtimesMatrix[runtime]
+ header_path = os.path.abspath(config['header'])
+ template = None
+
+ print(f'-- config: {config}')
+ if runtime == 'dev':
+ # to support sub-modules (https://github.com/paritytech/command-bot/issues/275)
+ search_manifest_path = f"cargo metadata --locked --format-version 1 --no-deps | jq -r '.packages[] | select(.name == \"{pallet.replace('_', '-')}\") | .manifest_path'"
+ print(f'-- running: {search_manifest_path}')
+ manifest_path = os.popen(search_manifest_path).read()
+ if not manifest_path:
+ print(f'-- pallet {pallet} not found in dev runtime')
+ exit(1)
+ package_dir = os.path.dirname(manifest_path)
+ print(f'-- package_dir: {package_dir}')
+ print(f'-- manifest_path: {manifest_path}')
+ output_path = os.path.join(package_dir, "src", "weights.rs")
+ template = config['template']
+ else:
+ default_path = f"./{config['path']}/src/weights"
+ xcm_path = f"./{config['path']}/src/weights/xcm"
+ output_path = default_path
+ if pallet.startswith("pallet_xcm_benchmarks"):
+ template = config['template']
+ output_path = xcm_path
+
+ print(f'-- benchmarking {pallet} in {runtime} into {output_path}')
+ cmd = f"frame-omni-bencher v1 benchmark pallet " \
+ f"--extrinsic=* " \
+ f"--runtime=target/{profile}/wbuild/{config['package']}/{config['package'].replace('-', '_')}.wasm " \
+ f"--pallet={pallet} " \
+ f"--header={header_path} " \
+ f"--output={output_path} " \
+ f"--wasm-execution=compiled " \
+ f"--steps=50 " \
+ f"--repeat=20 " \
+ f"--heap-pages=4096 " \
+ f"{f'--template={template} ' if template else ''}" \
+ f"--no-storage-info --no-min-squares --no-median-slopes"
+ print(f'-- Running: {cmd} \n')
+ status = os.system(cmd)
+ if status != 0 and not args.continue_on_fail:
+ print(f'Failed to benchmark {pallet} in {runtime}')
+ sys.exit(1)
+
+ # Otherwise collect failed benchmarks and print them at the end
+ # push failed pallets to failed_benchmarks
+ if status != 0:
+ failed_benchmarks[f'{runtime}'] = failed_benchmarks.get(f'{runtime}', []) + [pallet]
+ else:
+ successful_benchmarks[f'{runtime}'] = successful_benchmarks.get(f'{runtime}', []) + [pallet]
+
+ if failed_benchmarks:
+ print('❌ Failed benchmarks of runtimes/pallets:')
+ for runtime, pallets in failed_benchmarks.items():
+ print(f'-- {runtime}: {pallets}')
+
+ if successful_benchmarks:
+ print('✅ Successful benchmarks of runtimes/pallets:')
+ for runtime, pallets in successful_benchmarks.items():
+ print(f'-- {runtime}: {pallets}')
+
+ elif args.command == 'fmt':
+ command = f"cargo +nightly fmt"
+ print(f'Formatting with `{command}`')
+ nightly_status = os.system(f'{command}')
+ taplo_status = os.system('taplo format --config .config/taplo.toml')
+
+ if (nightly_status != 0 or taplo_status != 0) and not args.continue_on_fail:
+ print('❌ Failed to format code')
+ sys.exit(1)
+
+ elif args.command == 'update-ui':
+ command = 'sh ./scripts/update-ui-tests.sh'
+ print(f'Updating ui with `{command}`')
+ status = os.system(f'{command}')
+
+ if status != 0 and not args.continue_on_fail:
+ print('❌ Failed to format code')
+ sys.exit(1)
+
+ elif args.command == 'prdoc':
+ # Call the main function from ./github/scripts/generate-prdoc.py module
+ exit_code = generate_prdoc.main(args)
+ if exit_code != 0 and not args.continue_on_fail:
+ print('❌ Failed to generate prdoc')
+ sys.exit(exit_code)
+
+ print('🚀 Done')
+
+if __name__ == '__main__':
+ main()
\ No newline at end of file
diff --git a/.github/scripts/cmd/test_cmd.py b/.github/scripts/cmd/test_cmd.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2f29b075daed94a0c7380e031bb84e9a6889558
--- /dev/null
+++ b/.github/scripts/cmd/test_cmd.py
@@ -0,0 +1,339 @@
+import unittest
+from unittest.mock import patch, mock_open, MagicMock, call
+import json
+import sys
+import os
+import argparse
+
+# Mock data for runtimes-matrix.json
+mock_runtimes_matrix = [
+ {"name": "dev", "package": "kitchensink-runtime", "path": "substrate/frame", "header": "substrate/HEADER-APACHE2", "template": "substrate/.maintain/frame-weight-template.hbs"},
+ {"name": "westend", "package": "westend-runtime", "path": "polkadot/runtime/westend", "header": "polkadot/file_header.txt", "template": "polkadot/xcm/pallet-xcm-benchmarks/template.hbs"},
+ {"name": "rococo", "package": "rococo-runtime", "path": "polkadot/runtime/rococo", "header": "polkadot/file_header.txt", "template": "polkadot/xcm/pallet-xcm-benchmarks/template.hbs"},
+ {"name": "asset-hub-westend", "package": "asset-hub-westend-runtime", "path": "cumulus/parachains/runtimes/assets/asset-hub-westend", "header": "cumulus/file_header.txt", "template": "cumulus/templates/xcm-bench-template.hbs"},
+]
+
+def get_mock_bench_output(runtime, pallets, output_path, header, template = None):
+ return f"frame-omni-bencher v1 benchmark pallet --extrinsic=* " \
+ f"--runtime=target/release/wbuild/{runtime}-runtime/{runtime.replace('-', '_')}_runtime.wasm " \
+ f"--pallet={pallets} --header={header} " \
+ f"--output={output_path} " \
+ f"--wasm-execution=compiled " \
+ f"--steps=50 --repeat=20 --heap-pages=4096 " \
+ f"{f'--template={template} ' if template else ''}" \
+ f"--no-storage-info --no-min-squares --no-median-slopes"
+
+class TestCmd(unittest.TestCase):
+
+ def setUp(self):
+ self.patcher1 = patch('builtins.open', new_callable=mock_open, read_data=json.dumps(mock_runtimes_matrix))
+ self.patcher2 = patch('json.load', return_value=mock_runtimes_matrix)
+ self.patcher3 = patch('argparse.ArgumentParser.parse_known_args')
+ self.patcher4 = patch('os.system', return_value=0)
+ self.patcher5 = patch('os.popen')
+ self.patcher6 = patch('importlib.util.spec_from_file_location', return_value=MagicMock())
+ self.patcher7 = patch('importlib.util.module_from_spec', return_value=MagicMock())
+ self.patcher8 = patch('cmd.generate_prdoc.main', return_value=0)
+
+ self.mock_open = self.patcher1.start()
+ self.mock_json_load = self.patcher2.start()
+ self.mock_parse_args = self.patcher3.start()
+ self.mock_system = self.patcher4.start()
+ self.mock_popen = self.patcher5.start()
+ self.mock_spec_from_file_location = self.patcher6.start()
+ self.mock_module_from_spec = self.patcher7.start()
+ self.mock_generate_prdoc_main = self.patcher8.start()
+
+ # Ensure that cmd.py uses the mock_runtimes_matrix
+ import cmd
+ cmd.runtimesMatrix = mock_runtimes_matrix
+
+ def tearDown(self):
+ self.patcher1.stop()
+ self.patcher2.stop()
+ self.patcher3.stop()
+ self.patcher4.stop()
+ self.patcher5.stop()
+ self.patcher6.stop()
+ self.patcher7.stop()
+ self.patcher8.stop()
+
+ def test_bench_command_normal_execution_all_runtimes(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=list(map(lambda x: x['name'], mock_runtimes_matrix)),
+ pallet=['pallet_balances'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_balances\npallet_staking\npallet_something\n", # Output for dev runtime
+ "pallet_balances\npallet_staking\npallet_something\n", # Output for westend runtime
+ "pallet_staking\npallet_something\n", # Output for rococo runtime - no pallet here
+ "pallet_balances\npallet_staking\npallet_something\n", # Output for asset-hub-westend runtime
+ "./substrate/frame/balances/Cargo.toml\n", # Mock manifest path for dev -> pallet_balances
+ ]
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p kitchensink-runtime --profile release --features runtime-benchmarks"),
+ call("forklift cargo build -p westend-runtime --profile release --features runtime-benchmarks"),
+ call("forklift cargo build -p rococo-runtime --profile release --features runtime-benchmarks"),
+ call("forklift cargo build -p asset-hub-westend-runtime --profile release --features runtime-benchmarks"),
+
+ call(get_mock_bench_output('kitchensink', 'pallet_balances', './substrate/frame/balances/src/weights.rs', os.path.abspath('substrate/HEADER-APACHE2'), "substrate/.maintain/frame-weight-template.hbs")),
+ call(get_mock_bench_output('westend', 'pallet_balances', './polkadot/runtime/westend/src/weights', os.path.abspath('polkadot/file_header.txt'))),
+ # skips rococo benchmark
+ call(get_mock_bench_output('asset-hub-westend', 'pallet_balances', './cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights', os.path.abspath('cumulus/file_header.txt'))),
+ ]
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ def test_bench_command_normal_execution(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['westend'],
+ pallet=['pallet_balances', 'pallet_staking'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ header_path = os.path.abspath('polkadot/file_header.txt')
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_balances\npallet_staking\npallet_something\n", # Output for westend runtime
+ ]
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p westend-runtime --profile release --features runtime-benchmarks"),
+
+ # Westend runtime calls
+ call(get_mock_bench_output('westend', 'pallet_balances', './polkadot/runtime/westend/src/weights', header_path)),
+ call(get_mock_bench_output('westend', 'pallet_staking', './polkadot/runtime/westend/src/weights', header_path)),
+ ]
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+
+ def test_bench_command_normal_execution_xcm(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['westend'],
+ pallet=['pallet_xcm_benchmarks::generic'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ header_path = os.path.abspath('polkadot/file_header.txt')
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_balances\npallet_staking\npallet_something\npallet_xcm_benchmarks::generic\n", # Output for westend runtime
+ ]
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p westend-runtime --profile release --features runtime-benchmarks"),
+
+ # Westend runtime calls
+ call(get_mock_bench_output(
+ 'westend',
+ 'pallet_xcm_benchmarks::generic',
+ './polkadot/runtime/westend/src/weights/xcm',
+ header_path,
+ "polkadot/xcm/pallet-xcm-benchmarks/template.hbs"
+ )),
+ ]
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ def test_bench_command_two_runtimes_two_pallets(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['westend', 'rococo'],
+ pallet=['pallet_balances', 'pallet_staking'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_staking\npallet_balances\n", # Output for westend runtime
+ "pallet_staking\npallet_balances\n", # Output for rococo runtime
+ ]
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+ header_path = os.path.abspath('polkadot/file_header.txt')
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p westend-runtime --profile release --features runtime-benchmarks"),
+ call("forklift cargo build -p rococo-runtime --profile release --features runtime-benchmarks"),
+ # Westend runtime calls
+ call(get_mock_bench_output('westend', 'pallet_staking', './polkadot/runtime/westend/src/weights', header_path)),
+ call(get_mock_bench_output('westend', 'pallet_balances', './polkadot/runtime/westend/src/weights', header_path)),
+ # Rococo runtime calls
+ call(get_mock_bench_output('rococo', 'pallet_staking', './polkadot/runtime/rococo/src/weights', header_path)),
+ call(get_mock_bench_output('rococo', 'pallet_balances', './polkadot/runtime/rococo/src/weights', header_path)),
+ ]
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ def test_bench_command_one_dev_runtime(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['dev'],
+ pallet=['pallet_balances'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ manifest_dir = "substrate/frame/kitchensink"
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_balances\npallet_something", # Output for dev runtime
+ manifest_dir + "/Cargo.toml" # Output for manifest path in dev runtime
+ ]
+ header_path = os.path.abspath('substrate/HEADER-APACHE2')
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p kitchensink-runtime --profile release --features runtime-benchmarks"),
+ # Westend runtime calls
+ call(get_mock_bench_output(
+ 'kitchensink',
+ 'pallet_balances',
+ manifest_dir + "/src/weights.rs",
+ header_path,
+ "substrate/.maintain/frame-weight-template.hbs"
+ )),
+ ]
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ def test_bench_command_one_cumulus_runtime(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['asset-hub-westend'],
+ pallet=['pallet_assets'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_assets\n", # Output for asset-hub-westend runtime
+ ]
+ header_path = os.path.abspath('cumulus/file_header.txt')
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p asset-hub-westend-runtime --profile release --features runtime-benchmarks"),
+ # Asset-hub-westend runtime calls
+ call(get_mock_bench_output(
+ 'asset-hub-westend',
+ 'pallet_assets',
+ './cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights',
+ header_path
+ )),
+ ]
+
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ def test_bench_command_one_cumulus_runtime_xcm(self):
+ self.mock_parse_args.return_value = (argparse.Namespace(
+ command='bench',
+ runtime=['asset-hub-westend'],
+ pallet=['pallet_xcm_benchmarks::generic', 'pallet_assets'],
+ continue_on_fail=False,
+ quiet=False,
+ clean=False,
+ image=None
+ ), [])
+ self.mock_popen.return_value.read.side_effect = [
+ "pallet_assets\npallet_xcm_benchmarks::generic\n", # Output for asset-hub-westend runtime
+ ]
+ header_path = os.path.abspath('cumulus/file_header.txt')
+
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+
+ expected_calls = [
+ # Build calls
+ call("forklift cargo build -p asset-hub-westend-runtime --profile release --features runtime-benchmarks"),
+ # Asset-hub-westend runtime calls
+ call(get_mock_bench_output(
+ 'asset-hub-westend',
+ 'pallet_xcm_benchmarks::generic',
+ './cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm',
+ header_path,
+ "cumulus/templates/xcm-bench-template.hbs"
+ )),
+ call(get_mock_bench_output(
+ 'asset-hub-westend',
+ 'pallet_assets',
+ './cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights',
+ header_path
+ )),
+ ]
+
+ self.mock_system.assert_has_calls(expected_calls, any_order=True)
+
+ @patch('argparse.ArgumentParser.parse_known_args', return_value=(argparse.Namespace(command='fmt', continue_on_fail=False), []))
+ @patch('os.system', return_value=0)
+ def test_fmt_command(self, mock_system, mock_parse_args):
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+ mock_system.assert_any_call('cargo +nightly fmt')
+ mock_system.assert_any_call('taplo format --config .config/taplo.toml')
+
+ @patch('argparse.ArgumentParser.parse_known_args', return_value=(argparse.Namespace(command='update-ui', continue_on_fail=False), []))
+ @patch('os.system', return_value=0)
+ def test_update_ui_command(self, mock_system, mock_parse_args):
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+ mock_system.assert_called_with('sh ./scripts/update-ui-tests.sh')
+
+ @patch('argparse.ArgumentParser.parse_known_args', return_value=(argparse.Namespace(command='prdoc', continue_on_fail=False), []))
+ @patch('os.system', return_value=0)
+ def test_prdoc_command(self, mock_system, mock_parse_args):
+ with patch('sys.exit') as mock_exit:
+ import cmd
+ cmd.main()
+ mock_exit.assert_not_called()
+ self.mock_generate_prdoc_main.assert_called_with(mock_parse_args.return_value[0])
+
+if __name__ == '__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/.github/scripts/common/lib.sh b/.github/scripts/common/lib.sh
index f844e962c41def7625fa3d45ae3cbf81ecb57147..5361db398ae7bcaebd6717d726d50d50d5c5e301 100755
--- a/.github/scripts/common/lib.sh
+++ b/.github/scripts/common/lib.sh
@@ -299,22 +299,23 @@ function check_sha256() {
}
# Import GPG keys of the release team members
-# This is done in parallel as it can take a while sometimes
function import_gpg_keys() {
- GPG_KEYSERVER=${GPG_KEYSERVER:-"keyserver.ubuntu.com"}
+ GPG_KEYSERVER=${GPG_KEYSERVER:-"hkps://keyserver.ubuntu.com"}
SEC="9D4B2B6EB8F97156D19669A9FF0812D491B96798"
EGOR="E6FC4D4782EB0FA64A4903CCDB7D3555DD3932D3"
MORGAN="2E92A9D8B15D7891363D1AE8AF9E6C43F7F8C4CF"
+ PARITY_RELEASES="90BD75EBBB8E95CB3DA6078F94A4029AB4B35DAE"
- echo "Importing GPG keys from $GPG_KEYSERVER in parallel"
- for key in $SEC $EGOR $MORGAN; do
+ echo "Importing GPG keys from $GPG_KEYSERVER"
+ for key in $SEC $EGOR $MORGAN $PARITY_RELEASES; do
(
echo "Importing GPG key $key"
gpg --no-tty --quiet --keyserver $GPG_KEYSERVER --recv-keys $key
echo -e "5\ny\n" | gpg --no-tty --command-fd 0 --expert --edit-key $key trust;
- ) &
+ )
done
wait
+ gpg -k
}
# Check the GPG signature for a given binary
@@ -444,3 +445,28 @@ get_latest_release_tag() {
latest_release_tag=$(curl -s -H "$TOKEN" $api_base/paritytech/polkadot-sdk/releases/latest | jq -r '.tag_name')
printf $latest_release_tag
}
+
+function get_polkadot_node_version_from_code() {
+ # list all the files with node version
+ git grep -e "\(NODE_VERSION[^=]*= \)\".*\"" |
+ # fetch only the one we need
+ grep "primitives/src/lib.rs:" |
+ # Print only the version
+ awk '{ print $7 }' |
+ # Remove the quotes
+ sed 's/"//g' |
+ # Remove the semicolon
+ sed 's/;//g'
+}
+
+validate_stable_tag() {
+ tag="$1"
+ pattern='^stable[0-9]+(-[0-9]+)?$'
+
+ if [[ $tag =~ $pattern ]]; then
+ echo $tag
+ else
+ echo "The input '$tag' does not match the pattern."
+ exit 1
+ fi
+}
diff --git a/.github/scripts/generate-prdoc.py b/.github/scripts/generate-prdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3b6b523ecfd32d32470381c0d7a548b2d289041
--- /dev/null
+++ b/.github/scripts/generate-prdoc.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+
+"""
+Generate the PrDoc for a Pull Request with a specific number, audience and bump level.
+
+It downloads and parses the patch from the GitHub API to opulate the prdoc with all modified crates.
+This will delete any prdoc that already exists for the PR if `--force` is passed.
+
+Usage:
+ python generate-prdoc.py --pr 1234 --audience "TODO" --bump "TODO"
+"""
+
+import argparse
+import os
+import re
+import sys
+import subprocess
+import toml
+import yaml
+import requests
+
+from github import Github
+import whatthepatch
+from cargo_workspace import Workspace
+
+# Download the patch and pass the info into `create_prdoc`.
+def from_pr_number(n, audience, bump, force):
+ print(f"Fetching PR '{n}' from GitHub")
+ g = Github()
+
+ repo = g.get_repo("paritytech/polkadot-sdk")
+ pr = repo.get_pull(n)
+
+ patch_url = pr.patch_url
+ patch = requests.get(patch_url).text
+
+ create_prdoc(n, audience, pr.title, pr.body, patch, bump, force)
+
+def create_prdoc(pr, audience, title, description, patch, bump, force):
+ path = f"prdoc/pr_{pr}.prdoc"
+
+ if os.path.exists(path):
+ if force == True:
+ print(f"Overwriting existing PrDoc for PR {pr}")
+ else:
+ print(f"PrDoc already exists for PR {pr}. Use --force to overwrite.")
+ sys.exit(1)
+ else:
+ print(f"No preexisting PrDoc for PR {pr}")
+
+ prdoc = { "title": title, "doc": [{}], "crates": [] }
+
+ prdoc["doc"][0]["audience"] = audience
+ prdoc["doc"][0]["description"] = description
+
+ workspace = Workspace.from_path(".")
+
+ modified_paths = []
+ for diff in whatthepatch.parse_patch(patch):
+ new_path = diff.header.new_path
+ # Sometimes this lib returns `/dev/null` as the new path...
+ if not new_path.startswith("/dev"):
+ modified_paths.append(new_path)
+
+ modified_crates = {}
+ for p in modified_paths:
+ # Go up until we find a Cargo.toml
+ p = os.path.join(workspace.path, p)
+ while not os.path.exists(os.path.join(p, "Cargo.toml")):
+ print(f"Could not find Cargo.toml in {p}")
+ if p == '/':
+ exit(1)
+ p = os.path.dirname(p)
+
+ with open(os.path.join(p, "Cargo.toml")) as f:
+ manifest = toml.load(f)
+
+ if not "package" in manifest:
+ print(f"File was not in any crate: {p}")
+ continue
+
+ crate_name = manifest["package"]["name"]
+ if workspace.crate_by_name(crate_name).publish:
+ modified_crates[crate_name] = True
+ else:
+ print(f"Skipping unpublished crate: {crate_name}")
+
+ print(f"Modified crates: {modified_crates.keys()}")
+
+ for crate_name in modified_crates.keys():
+ entry = { "name": crate_name }
+
+ if bump == 'silent' or bump == 'ignore' or bump == 'no change':
+ entry["validate"] = False
+ else:
+ entry["bump"] = bump
+
+ print(f"Adding crate {entry}")
+ prdoc["crates"].append(entry)
+
+ # write the parsed PR documentation back to the file
+ with open(path, "w") as f:
+ yaml.dump(prdoc, f, sort_keys=False)
+ print(f"PrDoc for PR {pr} written to {path}")
+
+# Make the `description` a multiline string instead of escaping \r\n.
+def setup_yaml():
+ def yaml_multiline_string_presenter(dumper, data):
+ if len(data.splitlines()) > 1:
+ data = '\n'.join([line.rstrip() for line in data.strip().splitlines()])
+ return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
+ return dumper.represent_scalar('tag:yaml.org,2002:str', data)
+
+ yaml.add_representer(str, yaml_multiline_string_presenter)
+
+# parse_args is also used by cmd/cmd.py
+def setup_parser(parser=None):
+ if parser is None:
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--pr", type=int, required=True, help="The PR number to generate the PrDoc for." )
+ parser.add_argument("--audience", type=str, default="TODO", help="The audience of whom the changes may concern.")
+ parser.add_argument("--bump", type=str, default="TODO", help="A default bump level for all crates.")
+ parser.add_argument("--force", type=str, help="Whether to overwrite any existing PrDoc.")
+
+ return parser
+
+def main(args):
+ force = True if (args.force or "false").lower() == "true" else False
+ print(f"Args: {args}, force: {force}")
+ setup_yaml()
+ try:
+ from_pr_number(args.pr, args.audience, args.bump, force)
+ return 0
+ except Exception as e:
+ print(f"Error generating prdoc: {e}")
+ return 1
+
+if __name__ == "__main__":
+ args = setup_parser().parse_args()
+ main(args)
\ No newline at end of file
diff --git a/.github/scripts/generate-prdoc.requirements.txt b/.github/scripts/generate-prdoc.requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c17aceff63a0fcd095ba7f66fd9dc39ac3eba2c4
--- /dev/null
+++ b/.github/scripts/generate-prdoc.requirements.txt
@@ -0,0 +1,6 @@
+requests
+cargo-workspace
+PyGithub
+whatthepatch
+pyyaml
+toml
\ No newline at end of file
diff --git a/.github/scripts/generate-readmes.py b/.github/scripts/generate-readmes.py
new file mode 100755
index 0000000000000000000000000000000000000000..f838eaa29a74daafe9616d779d070aff36891347
--- /dev/null
+++ b/.github/scripts/generate-readmes.py
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+
+"""
+A script to generate READMEs for all public crates,
+if they do not already have one.
+
+It relies on functions from the `check-workspace.py` script.
+
+The resulting README is based on a template defined below,
+and includes the crate name, description, license,
+and optionally - the SDK release version.
+
+# Example
+
+```sh
+python3 -m pip install toml
+.github/scripts/generate-readmes.py . --sdk-version 1.15.0
+```
+"""
+
+import os
+import toml
+import importlib
+import argparse
+
+check_workspace = importlib.import_module("check-workspace")
+
+README_TEMPLATE = """
+
+
+
+# {name}
+
+This crate is part of the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk/).
+
+
Emergency Bypass
+
+ If you really need to bypass this check: add validate: false to each crate
+ in the Prdoc where a breaking change is introduced. This will release a new major
+ version of that crate and all its reverse dependencies and basically break the release.
+
+
+
+ EOF
+ gh issue comment $PR --edit-last -F msg.txt || gh issue comment $PR -F msg.txt
+
+ echo "PRDOC_EXTRA_ARGS=--max-bump minor" >> $GITHUB_ENV
- name: Rust Cache
uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2.7.3
with:
cache-on-failure: true
- - name: install parity-publish
- run: cargo install parity-publish@0.6.0
-
- name: Rust compilation prerequisites
run: |
rustup default $TOOLCHAIN
- rustup target add wasm32-unknown-unknown --toolchain $TOOLCHAIN
rustup component add rust-src --toolchain $TOOLCHAIN
- - name: extra git setup
- run: |
- git config --global --add safe.directory '*'
- git fetch --no-tags --no-recurse-submodules --depth=1 origin master
- git branch old origin/master
+ - name: install parity-publish
+ # Set the target dir to cache the build.
+ run: CARGO_TARGET_DIR=./target/ cargo install parity-publish@0.8.0 --locked -q
- name: check semver
run: |
export CARGO_TARGET_DIR=target
export RUSTFLAGS='-A warnings -A missing_docs'
export SKIP_WASM_BUILD=1
- if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc -v --toolchain $TOOLCHAIN; then
+
+ if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc $PRDOC_EXTRA_ARGS -v --toolchain $TOOLCHAIN; then
+
cat <> $GITHUB_OUTPUT
+
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
fmt:
runs-on: ubuntu-latest
- timeout-minutes: 10
- needs: [set-image]
+ timeout-minutes: 20
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Cargo fmt
run: cargo +nightly fmt --all -- --check
check-dependency-rules:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: check dependency rules
run: |
cd substrate/
../.gitlab/ensure-deps.sh
check-rust-feature-propagation:
runs-on: ubuntu-latest
- timeout-minutes: 10
- needs: [set-image]
+ timeout-minutes: 20
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: fetch deps
run: |
# Pull all dependencies eagerly:
@@ -65,31 +56,31 @@ jobs:
time zepter run check
test-rust-features:
runs-on: ubuntu-latest
- timeout-minutes: 10
- needs: [set-image]
+ timeout-minutes: 20
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: run rust features
run: bash .gitlab/rust-features.sh .
check-toml-format:
runs-on: ubuntu-latest
- timeout-minutes: 10
- needs: [set-image]
+ timeout-minutes: 20
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: check toml format
run: |
taplo format --check --config .config/taplo.toml
echo "Please run `taplo format --config .config/taplo.toml` to fix any toml formatting issues"
check-workspace:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.0 (22. Sep 2023)
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.0 (22. Sep 2023)
- name: install python deps
run: |
sudo apt-get update && sudo apt-get install -y python3-pip python3
@@ -100,16 +91,18 @@ jobs:
--exclude
"substrate/frame/contracts/fixtures/build"
"substrate/frame/contracts/fixtures/contracts/common"
+ "substrate/frame/revive/fixtures/build"
+ "substrate/frame/revive/fixtures/contracts/common"
- name: deny git deps
run: python3 .github/scripts/deny-git-deps.py .
check-markdown:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
steps:
- name: Checkout sources
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Setup Node.js
- uses: actions/setup-node@v4.0.1
+ uses: actions/setup-node@v4.0.3
with:
node-version: "18.x"
registry-url: "https://npm.pkg.github.com"
@@ -127,12 +120,12 @@ jobs:
markdownlint --config "$CONFIG" --ignore target .
check-umbrella:
runs-on: ubuntu-latest
- timeout-minutes: 10
- needs: [set-image]
+ timeout-minutes: 20
+ needs: [preflight]
container:
- image: ${{ needs.set-image.outputs.IMAGE }}
+ image: ${{ needs.preflight.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.0 (22. Sep 2023)
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.0 (22. Sep 2023)
- name: install python deps
run: pip3 install "cargo-workspace>=1.2.4" toml
- name: check umbrella correctness
@@ -154,3 +147,54 @@ jobs:
git diff
exit 1
fi
+ check-fail-ci:
+ runs-on: ubuntu-latest
+ container:
+ # there's no "rg" in ci-unified, and tools is a smaller image anyway
+ image: "paritytech/tools:latest"
+ # paritytech/tools uses "nonroot" user by default, which doesn't have enough
+ # permissions to create GHA context
+ options: --user root
+ steps:
+ - name: Fetch latest code
+ uses: actions/checkout@v4
+ - name: Check
+ run: |
+ set +e
+ rg --line-number --hidden --type rust --glob '!{.git,target}' "$ASSERT_REGEX" .; exit_status=$?
+ if [ $exit_status -eq 0 ]; then
+ echo "$ASSERT_REGEX was found, exiting with 1";
+ exit 1;
+ else
+ echo "No $ASSERT_REGEX was found, exiting with 0";
+ exit 0;
+ fi
+ env:
+ ASSERT_REGEX: "FAIL-CI"
+ GIT_DEPTH: 1
+
+ confirm-required-checks-quick-jobs-passed:
+ runs-on: ubuntu-latest
+ name: All quick checks passed
+ # If any new job gets added, be sure to add it to this array
+ needs:
+ - fmt
+ - check-dependency-rules
+ - check-rust-feature-propagation
+ - test-rust-features
+ - check-toml-format
+ - check-workspace
+ - check-markdown
+ - check-umbrella
+ - check-fail-ci
+ if: always() && !cancelled()
+ steps:
+ - run: |
+ tee resultfile <<< '${{ toJSON(needs) }}'
+ FAILURES=$(cat resultfile | grep '"result": "failure"' | wc -l)
+ if [ $FAILURES -gt 0 ]; then
+ echo "### At least one required job failed ❌" >> $GITHUB_STEP_SUMMARY
+ exit 1
+ else
+ echo '### Good job! All the required jobs passed 🚀' >> $GITHUB_STEP_SUMMARY
+ fi
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 0000000000000000000000000000000000000000..f765d79254c856195271978942ea2eb550f3e7f6
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,94 @@
+name: Checks
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ types: [opened, synchronize, reopened, ready_for_review]
+ merge_group:
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ cargo-clippy:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ env:
+ RUSTFLAGS: "-D warnings"
+ SKIP_WASM_BUILD: 1
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ forklift cargo clippy --all-targets --locked --workspace
+ forklift cargo clippy --all-targets --all-features --locked --workspace
+ check-try-runtime:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ forklift cargo check --locked --all --features try-runtime
+ # this is taken from cumulus
+ # Check that parachain-template will compile with `try-runtime` feature flag.
+ forklift cargo check --locked -p parachain-template-node --features try-runtime
+ # add after https://github.com/paritytech/substrate/pull/14502 is merged
+ # experimental code may rely on try-runtime and vice-versa
+ forklift cargo check --locked --all --features try-runtime,experimental
+ # check-core-crypto-features works fast without forklift
+ check-core-crypto-features:
+ runs-on: ${{ needs.preflight.outputs.RUNNER }}
+ needs: [preflight]
+ # if: ${{ needs.preflight.outputs.changes_rust }}
+ timeout-minutes: 30
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
+ - name: script
+ run: |
+ cd substrate/primitives/core
+ ./check-features-variants.sh
+ cd -
+ cd substrate/primitives/application-crypto
+ ./check-features-variants.sh
+ cd -
+ cd substrate/primitives/keyring
+ ./check-features-variants.sh
+ cd -
+ # name of this job must be unique across all workflows
+ # otherwise GitHub will mark all these jobs as required
+ confirm-required-checks-passed:
+ runs-on: ubuntu-latest
+ name: All checks passed
+ # If any new job gets added, be sure to add it to this array
+ needs: [cargo-clippy, check-try-runtime, check-core-crypto-features]
+ if: always() && !cancelled()
+ steps:
+ - run: |
+ tee resultfile <<< '${{ toJSON(needs) }}'
+ FAILURES=$(cat resultfile | grep '"result": "failure"' | wc -l)
+ if [ $FAILURES -gt 0 ]; then
+ echo "### At least one required job failed ❌" >> $GITHUB_STEP_SUMMARY
+ exit 1
+ else
+ echo '### Good job! All the required jobs passed 🚀' >> $GITHUB_STEP_SUMMARY
+ fi
diff --git a/.github/workflows/cmd-tests.yml b/.github/workflows/cmd-tests.yml
new file mode 100644
index 0000000000000000000000000000000000000000..37f1747d0b9eac72cf8e6c10534a8c31402cd905
--- /dev/null
+++ b/.github/workflows/cmd-tests.yml
@@ -0,0 +1,18 @@
+name: Command Bot Tests
+
+on:
+ pull_request:
+
+permissions:
+ contents: read
+
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - run: python3 .github/scripts/cmd/test_cmd.py
diff --git a/.github/workflows/cmd.yml b/.github/workflows/cmd.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5498beb50ccb16740cd3c8eae09dd85fc0ff6206
--- /dev/null
+++ b/.github/workflows/cmd.yml
@@ -0,0 +1,455 @@
+name: Command
+
+on:
+ issue_comment: # listen for comments on issues
+ types: [created]
+
+permissions: # allow the action to comment on the PR
+ contents: write
+ issues: write
+ pull-requests: write
+ actions: read
+
+jobs:
+ is-org-member:
+ if: startsWith(github.event.comment.body, '/cmd')
+ runs-on: ubuntu-latest
+ outputs:
+ member: ${{ steps.is-member.outputs.result }}
+ steps:
+ - name: Generate token
+ id: generate_token
+ uses: tibdex/github-app-token@v2.1.0
+ with:
+ app_id: ${{ secrets.CMD_BOT_APP_ID }}
+ private_key: ${{ secrets.CMD_BOT_APP_KEY }}
+
+ - name: Check if user is a member of the organization
+ id: is-member
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ steps.generate_token.outputs.token }}
+ result-encoding: string
+ script: |
+ const fs = require("fs");
+ try {
+ const org = '${{ github.event.repository.owner.login }}';
+ const username = '${{ github.event.comment.user.login }}';
+
+ const membership = await github.rest.orgs.checkMembershipForUser({
+ org: org,
+ username: username
+ });
+
+ console.log(membership, membership.status, membership.status === 204);
+
+ if (membership.status === 204) {
+ return 'true';
+ } else {
+ console.log(membership);
+ fs.appendFileSync(process.env["GITHUB_STEP_SUMMARY"], `${membership.data && membership.data.message || 'Unknown error happened, please check logs'}`);
+ }
+ } catch (error) {
+ console.log(error)
+ }
+
+ return 'false';
+
+ reject-non-members:
+ needs: is-org-member
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && needs.is-org-member.outputs.member != 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Add reaction to rejected comment
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'confused'
+ })
+
+ - name: Comment PR (Rejected)
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Sorry, only members of the organization ${{ github.event.repository.owner.login }} members can run commands.`
+ })
+
+ acknowledge:
+ needs: is-org-member
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && needs.is-org-member.outputs.member == 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Add reaction to triggered comment
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'eyes'
+ })
+
+ clean:
+ needs: is-org-member
+ runs-on: ubuntu-latest
+ steps:
+ - name: Clean previous comments
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && contains(github.event.comment.body, '--clean') && needs.is-org-member.outputs.member == 'true' }}
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.listComments({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo
+ }).then(comments => {
+ for (let comment of comments.data) {
+ console.log(comment)
+ if (
+ ${{ github.event.comment.id }} !== comment.id &&
+ (
+ (
+ (
+ comment.body.startsWith('Command') ||
+ comment.body.startsWith('Command') ||
+ comment.body.startsWith('Sorry, only ')
+ ) && comment.user.type === 'Bot'
+ ) ||
+ (comment.body.startsWith('/cmd') && comment.user.login === context.actor)
+ )
+ ) {
+ github.rest.issues.deleteComment({
+ comment_id: comment.id,
+ owner: context.repo.owner,
+ repo: context.repo.repo
+ })
+ }
+ }
+ })
+ help:
+ needs: [clean, is-org-member]
+ if: ${{ startsWith(github.event.comment.body, '/cmd') && contains(github.event.comment.body, '--help') && needs.is-org-member.outputs.member == 'true' }}
+ runs-on: ubuntu-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+
+ - name: Get command
+ uses: actions-ecosystem/action-regex-match@v2
+ id: get-pr-comment
+ with:
+ text: ${{ github.event.comment.body }}
+ regex: '^(\/cmd )([-\/\s\w.=:]+)$' # see explanation in docs/contributor/commands-readme.md#examples
+
+ - name: Save output of help
+ id: help
+ env:
+ CMD: ${{ steps.get-pr-comment.outputs.group2 }} # to avoid "" around the command
+ run: |
+ echo 'help<> $GITHUB_OUTPUT
+ python3 -m pip install -r .github/scripts/generate-prdoc.requirements.txt
+ python3 .github/scripts/cmd/cmd.py $CMD >> $GITHUB_OUTPUT
+ echo 'EOF' >> $GITHUB_OUTPUT
+
+ - name: Comment PR (Help)
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command help:
+
+ \`\`\`
+ ${{ steps.help.outputs.help }}
+ \`\`\`
+
+ > $GITHUB_OUTPUT
+
+ - name: Comment PR (End)
+ if: ${{ !failure() && !contains(github.event.comment.body, '--quiet') }}
+ uses: actions/github-script@v7
+ env:
+ SUBWEIGHT: "${{ steps.subweight.outputs.result }}"
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ let runUrl = ${{ steps.build-link.outputs.run_url }}
+ let subweight = process.env.SUBWEIGHT;
+
+ let subweightCollapsed = subweight
+ ? `\n\nSubweight results: \n\n${subweight}\n\n `
+ : '';
+
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command "${{ steps.get-pr-comment.outputs.group2 }}" has finished ✅ [See logs here](${runUrl})${subweightCollapsed}`
+ })
+
+ - name: Comment PR (Failure)
+ if: ${{ failure() && !contains(github.event.comment.body, '--quiet') }}
+ uses: actions/github-script@v7
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ let jobUrl = ${{ steps.build-link.outputs.job_url }}
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: `Command "${{ steps.get-pr-comment.outputs.group2 }}" has failed ❌! [See logs here](${jobUrl})`
+ })
+
+ - name: Add 😕 reaction on failure
+ uses: actions/github-script@v7
+ if: ${{ failure() }}
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: 'confused'
+ })
+
+ - name: Add 👍 reaction on success
+ uses: actions/github-script@v7
+ if: ${{ !failure() }}
+ with:
+ github-token: ${{ secrets.GITHUB_TOKEN }}
+ script: |
+ github.rest.reactions.createForIssueComment({
+ comment_id: ${{ github.event.comment.id }},
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ content: '+1'
+ })
diff --git a/.github/workflows/command-backport.yml b/.github/workflows/command-backport.yml
new file mode 100644
index 0000000000000000000000000000000000000000..5b32f954d0cd2a45c7f6f3aba2eda8c2280605d4
--- /dev/null
+++ b/.github/workflows/command-backport.yml
@@ -0,0 +1,95 @@
+name: Backport into stable
+
+on:
+ # This trigger can be problematic, see: https://securitylab.github.com/resources/github-actions-preventing-pwn-requests/
+ # In our case it is fine since we only run it on merged Pull Requests and do not execute any of the repo code itself.
+ pull_request_target:
+ types: [ closed, labeled ]
+
+permissions:
+ contents: write # so it can comment
+ pull-requests: write # so it can create pull requests
+ issues: write
+
+jobs:
+ backport:
+ name: Backport pull request
+ runs-on: ubuntu-latest
+
+ # The 'github.event.pull_request.merged' ensures that it got into master:
+ if: >
+ ( !startsWith(github.event.pull_request.base.ref, 'stable') ) &&
+ (
+ github.event_name == 'pull_request_target' &&
+ github.event.pull_request.merged &&
+ github.event.pull_request.base.ref == 'master' &&
+ contains(github.event.pull_request.labels.*.name, 'A4-needs-backport')
+ )
+ steps:
+ - uses: actions/checkout@v4
+
+ - name: Generate token
+ id: generate_token
+ uses: tibdex/github-app-token@v2.1.0
+ with:
+ app_id: ${{ secrets.CMD_BOT_APP_ID }}
+ private_key: ${{ secrets.CMD_BOT_APP_KEY }}
+
+ - name: Create backport pull requests
+ uses: korthout/backport-action@v3
+ id: backport
+ with:
+ target_branches: stable2407 stable2409
+ merge_commits: skip
+ github_token: ${{ steps.generate_token.outputs.token }}
+ pull_description: |
+ Backport #${pull_number} into `${target_branch}` from ${pull_author}.
+
+ See the [documentation](https://github.com/paritytech/polkadot-sdk/blob/master/docs/BACKPORT.md) on how to use this bot.
+
+
+ pull_title: |
+ [${target_branch}] Backport #${pull_number}
+ experimental: >
+ {
+ "conflict_resolution": "draft_commit_conflicts"
+ }
+ copy_assignees: true
+
+ - name: Label Backports
+ if: ${{ steps.backport.outputs.created_pull_numbers != '' }}
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const pullNumbers = '${{ steps.backport.outputs.created_pull_numbers }}'.split(' ');
+
+ for (const pullNumber of pullNumbers) {
+ await github.rest.issues.addLabels({
+ issue_number: parseInt(pullNumber),
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ labels: ['A3-backport']
+ });
+ console.log(`Added A3-backport label to PR #${pullNumber}`);
+ }
+
+ - name: Request Review
+ if: ${{ steps.backport.outputs.created_pull_numbers != '' }}
+ uses: actions/github-script@v7
+ with:
+ script: |
+ const pullNumbers = '${{ steps.backport.outputs.created_pull_numbers }}'.split(' ');
+ const reviewer = '${{ github.event.pull_request.user.login }}';
+
+ for (const pullNumber of pullNumbers) {
+ await github.pulls.createReviewRequest({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ pull_number: parseInt(pullNumber),
+ reviewers: [ reviewer ]
+ });
+ console.log(`Requested review from ${reviewer} for PR #${pullNumber}`);
+ }
diff --git a/.github/workflows/command-bench-all.yml b/.github/workflows/command-bench-all.yml
deleted file mode 100644
index b3fa0868c48797775c0ef8eff67e3acbd7f6facd..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench-all.yml
+++ /dev/null
@@ -1,97 +0,0 @@
-name: Command Bench All
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - pallet
- - substrate
- - polkadot
- - cumulus
- pallet:
- description: Pallet
- required: false
- type: string
- default: pallet_name
- target_dir:
- description: Target directory
- type: choice
- options:
- - substrate
- - polkadot
- - cumulus
- runtime:
- description: Runtime
- type: choice
- options:
- - rococo
- - westend
- - asset-hub-kusama
- - asset-hub-polkadot
- - asset-hub-rococo
- - asset-hub-westend
- - bridge-hub-kusama
- - bridge-hub-polkadot
- - bridge-hub-rococo
- - bridge-hub-westend
- - collectives-polkadot
- - collectives-westend
- - coretime-rococo
- - coretime-westend
- - contracts-rococo
- - glutton-kusama
- - glutton-westend
- - people-rococo
- - people-westend
-
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench-all:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-benchmark
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench all
- run: |
- "./scripts/bench-all.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench-overhead.yml b/.github/workflows/command-bench-overhead.yml
deleted file mode 100644
index 735b401021061c3dde3dd065a12d9f6f538b8c93..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench-overhead.yml
+++ /dev/null
@@ -1,75 +0,0 @@
-name: Command Bench Overhead
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - default
- - substrate
- - cumulus
- runtime:
- description: Runtime
- type: choice
- options:
- - rococo
- - westend
- - asset-hub-rococo
- - asset-hub-westend
- target_dir:
- description: Target directory
- type: choice
- options:
- - polkadot
- - substrate
- - cumulus
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench-overhead:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-benchmark
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench overhead
- run: |
- "./scripts/bench.sh" "${{ inputs.benchmark }}" --subcommand "overhead" --runtime "${{ inputs.runtime }}" --target_dir "${{ inputs.target_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-bench.yml b/.github/workflows/command-bench.yml
deleted file mode 100644
index 0ff166be48c193aa00e858b3bf7138b856487e24..0000000000000000000000000000000000000000
--- a/.github/workflows/command-bench.yml
+++ /dev/null
@@ -1,122 +0,0 @@
-name: Command Bench
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- benchmark:
- description: Pallet benchmark
- type: choice
- required: true
- options:
- - substrate-pallet
- - polkadot-pallet
- - cumulus-assets
- - cumulus-collectives
- - cumulus-coretime
- - cumulus-bridge-hubs
- - cumulus-contracts
- - cumulus-glutton
- - cumulus-starters
- - cumulus-people
- - cumulus-testing
- subcommand:
- description: Subcommand
- type: choice
- required: true
- options:
- - pallet
- - xcm
- runtime:
- description: Runtime
- type: choice
- options:
- - dev
- - rococo
- - westend
- - asset-hub-westend
- - asset-hub-rococo
- - collectives-westend
- - coretime-rococo
- - coretime-westend
- - bridge-hub-rococo
- - bridge-hub-westend
- - contracts-rococo
- - glutton-westend
- - glutton-westend-dev-1300
- - seedling
- - shell
- - people-westend
- - people-rococo
- - penpal
- - rococo-parachain
- pallet:
- description: Pallet
- type: string
- default: pallet_name
- target_dir:
- description: Target directory
- type: choice
- options:
- - substrate
- - polkadot
- - cumulus
- runtime_dir:
- description: Runtime directory
- type: choice
- options:
- - people
- - collectives
- - coretime
- - bridge-hubs
- - contracts
- - glutton
- - starters
- - testing
-
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-bench:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-benchmark
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run bench
- run: |
- "./scripts/bench.sh" "${{ inputs.benchmark }}" --runtime "${{ inputs.runtime }}" --pallet "${{ inputs.pallet }}" --target_dir "${{ inputs.target_dir }}" --subcommand "${{ inputs.subcommand }}" --runtime_dir "${{ inputs.runtime_dir }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-fmt.yml b/.github/workflows/command-fmt.yml
deleted file mode 100644
index d415007d938390ded98a95f5f5c8ecc61fb0dc84..0000000000000000000000000000000000000000
--- a/.github/workflows/command-fmt.yml
+++ /dev/null
@@ -1,54 +0,0 @@
-name: Command FMT
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-fmt:
- needs: [set-image]
- runs-on: ubuntu-latest
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run FMT
- run: |
- # format toml.
- # since paritytech/ci-unified:bullseye-1.73.0-2023-11-01-v20231204 includes taplo-cli
- taplo format --config .config/taplo.toml
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/command-inform.yml b/.github/workflows/command-inform.yml
index 1c7323c998dfee3ba822f4bcb655c57a958fd80f..97346395319362b0455bcbcfbb490fa23e6b3b07 100644
--- a/.github/workflows/command-inform.yml
+++ b/.github/workflows/command-inform.yml
@@ -2,14 +2,21 @@ name: Inform of new command action
on:
issue_comment:
- types: [created]
+ types: [ created ]
jobs:
comment:
runs-on: ubuntu-latest
+ # Temporary disable the bot until the new command bot works properly
+ if: github.event.issue.pull_request && startsWith(github.event.comment.body, 'bot ') && false # disabled for now, until tested
steps:
- - name: Inform that the new command exist
- if: ${{ github.event.issue.pull_request && startsWith(github.event.comment.body, 'bot ') }}
- run: gh pr comment ${{ github.event.issue.number }} --body 'We are migrating this bot to be a GitHub Actiondocumentation on how to use it '
- env:
- GH_TOKEN: ${{ github.token }}
+ - name: Inform that the new command exist
+ uses: actions/github-script@v7
+ with:
+ script: |
+ github.rest.issues.createComment({
+ issue_number: context.issue.number,
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ body: 'We have migrated the command bot to GHAhere . Soon the old commands will be disabled.'
+ })
\ No newline at end of file
diff --git a/.github/workflows/command-prdoc.yml b/.github/workflows/command-prdoc.yml
new file mode 100644
index 0000000000000000000000000000000000000000..aa9de9474a7b434deaab92821ab3b9bdad4b82e6
--- /dev/null
+++ b/.github/workflows/command-prdoc.yml
@@ -0,0 +1,84 @@
+name: Command PrDoc
+
+on:
+ workflow_dispatch:
+ inputs:
+ pr:
+ type: number
+ description: Number of the Pull Request
+ required: true
+ bump:
+ type: choice
+ description: Default bump level for all crates
+ default: "TODO"
+ required: true
+ options:
+ - "TODO"
+ - "no change"
+ - "patch"
+ - "minor"
+ - "major"
+ audience:
+ type: choice
+ description: Audience of the PrDoc
+ default: "TODO"
+ required: true
+ options:
+ - "TODO"
+ - "Runtime Dev"
+ - "Runtime User"
+ - "Node Dev"
+ - "Node User"
+ overwrite:
+ type: choice
+ description: Overwrite existing PrDoc
+ default: "true"
+ required: true
+ options:
+ - "true"
+ - "false"
+
+concurrency:
+ group: command-prdoc
+ cancel-in-progress: true
+
+jobs:
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ cmd-prdoc:
+ needs: [preflight]
+ runs-on: ubuntu-latest
+ timeout-minutes: 20
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ permissions:
+ contents: write
+ pull-requests: write
+ steps:
+ - name: Download repo
+ uses: actions/checkout@v4
+ - name: Install gh cli
+ id: gh
+ uses: ./.github/actions/set-up-gh
+ with:
+ pr-number: ${{ inputs.pr }}
+ GH_TOKEN: ${{ github.token }}
+ - name: Generate PrDoc
+ run: |
+ python3 -m pip install -q cargo-workspace PyGithub whatthepatch pyyaml toml
+
+ python3 .github/scripts/generate-prdoc.py --pr "${{ inputs.pr }}" --bump "${{ inputs.bump }}" --audience "${{ inputs.audience }}" --force "${{ inputs.overwrite }}"
+
+ - name: Report failure
+ if: ${{ failure() }}
+ run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
+ env:
+ RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+ GH_TOKEN: ${{ github.token }}
+ - name: Push Commit
+ uses: stefanzweifel/git-auto-commit-action@v5
+ with:
+ commit_message: Add PrDoc (auto generated)
+ branch: ${{ steps.gh.outputs.branch }}
+ file_pattern: 'prdoc/*.prdoc'
diff --git a/.github/workflows/command-update-ui.yml b/.github/workflows/command-update-ui.yml
deleted file mode 100644
index 9b9c45c5c0b9d78f0287b8d00314e0c58fff0c69..0000000000000000000000000000000000000000
--- a/.github/workflows/command-update-ui.yml
+++ /dev/null
@@ -1,55 +0,0 @@
-name: Command Update UI
-
-on:
- workflow_dispatch:
- inputs:
- pr:
- description: Number of the Pull Request
- required: true
- rust-version:
- description: Version of rust. Example 1.70
- required: false
-
-jobs:
- set-image:
- runs-on: ubuntu-latest
- outputs:
- IMAGE: ${{ steps.set_image.outputs.IMAGE }}
- steps:
- - name: Checkout
- uses: actions/checkout@v4
- - id: set_image
- run: cat .github/env >> $GITHUB_OUTPUT
- cmd-update-ui:
- needs: [set-image]
- runs-on: arc-runners-polkadot-sdk-beefy
- container:
- image: ${{ needs.set-image.outputs.IMAGE }}
- steps:
- - name: Download repo
- uses: actions/checkout@v4
- - name: Install gh cli
- id: gh
- uses: ./.github/actions/set-up-gh
- with:
- pr-number: ${{ inputs.pr }}
- GH_TOKEN: ${{ github.token }}
- - name: Run update-ui
- run: |
- "./scripts/update-ui-tests.sh" "${{ inputs.rust-version }}"
- - name: Report failure
- if: ${{ failure() }}
- run: gh pr comment ${{ inputs.pr }} --body "Command failed ❌ Run by @${{ github.actor }} for ${{ github.workflow }} failed. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
- - run: git pull --rebase
- - uses: stefanzweifel/git-auto-commit-action@v5
- with:
- commit_message: cmd-action - ${{ github.workflow }}
- branch: ${{ steps.gh.outputs.branch }}
- - name: Report succeed
- run: gh pr comment ${{ inputs.pr }} --body "Action completed 🎉🎉 Run by @${{ github.actor }} for ${{ github.workflow }} completed 🎉. See logs here ."
- env:
- RUN: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
- GH_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..514bac3973bf76dbab6a8c246054400d3fb1c4e9
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,130 @@
+name: Docs
+
+on:
+ push:
+ branches:
+ - master
+ pull_request:
+ types: [opened, synchronize, reopened, ready_for_review, labeled]
+ merge_group:
+
+concurrency:
+ group: ${{ github.ref }}
+ cancel-in-progress: ${{ github.ref != 'refs/heads/master' }}
+
+jobs:
+ preflight:
+ uses: ./.github/workflows/reusable-preflight.yml
+
+ test-rustdoc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo doc --workspace --all-features --no-deps
+ env:
+ SKIP_WASM_BUILD: 1
+ test-doc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo test --doc --workspace
+ env:
+ RUSTFLAGS: "-Cdebug-assertions=y -Dwarnings"
+
+ build-rustdoc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [preflight, test-rustdoc]
+ container:
+ image: ${{ needs.preflight.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@v4
+ - run: forklift cargo doc --all-features --workspace --no-deps
+ env:
+ SKIP_WASM_BUILD: 1
+ RUSTDOCFLAGS: "-Dwarnings --default-theme=ayu --html-in-header ./docs/sdk/assets/header.html --extend-css ./docs/sdk/assets/theme.css --html-after-content ./docs/sdk/assets/after-content.html"
+ - run: rm -f ./target/doc/.lock
+ - run: mv ./target/doc ./crate-docs
+ - name: Inject Simple Analytics script
+ run: |
+ script_content=""]
- homepage = "https://substrate.io"
+ homepage = "https://paritytech.github.io/polkadot-sdk/"
[workspace]
members = [
@@ -90,7 +89,12 @@ jobs:
"runtime",
]
resolver = "2"
+
+ [workspace.dependencies]
EOF
+
+ echo "$(toml get -r ./runtime/Cargo.toml 'package.name') = { path = \"./runtime\", default-features = false }" >> Cargo.toml
+ echo "$(toml get -r ./pallets/template/Cargo.toml 'package.name') = { path = \"./pallets/template\", default-features = false }" >> Cargo.toml
shell: bash
working-directory: polkadot-sdk/templates/${{ matrix.template }}/
- name: Update workspace configuration
@@ -116,9 +120,12 @@ jobs:
- name: Copy over the new changes
run: |
cp -r polkadot-sdk/templates/${{ matrix.template }}/* "${{ env.template-path }}/"
+
+ - name: Run psvm on monorepo workspace dependencies
+ run: psvm -o -v ${{ github.event.inputs.stable_release_branch }} -p ./Cargo.toml
+ working-directory: polkadot-sdk/
- name: Copy over required workspace dependencies
run: |
- echo -e "\n[workspace.dependencies]" >> Cargo.toml
set +e
# If a workspace dependency is required..
while cargo tree --depth 1 --prefix none --no-dedupe 2>&1 | grep 'was not found in `workspace.dependencies`'; do
@@ -150,18 +157,22 @@ jobs:
timeout-minutes: 90
- name: Create PR on failure
if: failure() && steps.check-compilation.outcome == 'failure'
- uses: peter-evans/create-pull-request@5b4a9f6a9e2af26e5f02351490b90d01eb8ec1e5 # v5
+ uses: peter-evans/create-pull-request@8867c4aba1b742c39f8d0ba35429c2dfa4b6cb20 # v5
with:
path: "${{ env.template-path }}"
token: ${{ steps.app_token.outputs.token }}
add-paths: |
./*
- title: "[Don't merge] Update the ${{ matrix.template }} template to ${{ github.event.inputs.crate_release_version }}"
+ title: "[Don't merge] Update the ${{ matrix.template }} template to ${{ github.event.inputs.stable_release_branch }}"
body: "The template has NOT been successfully built and needs to be inspected."
- branch: "update-template/${{ github.event.inputs.crate_release_version }}"
- - name: Push changes
- run: |
- git add -A .
- git commit --allow-empty -m "Update to ${{ github.event.inputs.crate_release_version }} triggered by ${{ github.event_name }}"
- git push
- working-directory: "${{ env.template-path }}"
+ branch: "update-template/${{ github.event.inputs.stable_release_branch }}"
+ - name: Create PR on success
+ uses: peter-evans/create-pull-request@8867c4aba1b742c39f8d0ba35429c2dfa4b6cb20 # v5
+ with:
+ path: "${{ env.template-path }}"
+ token: ${{ steps.app_token.outputs.token }}
+ add-paths: |
+ ./*
+ title: "Update the ${{ matrix.template }} template to ${{ github.event.inputs.stable_release_branch }}"
+ body: "This synchronizes the template to the ${{ github.event.inputs.stable_release_branch }} branch."
+ branch: "update-template/${{ github.event.inputs.stable_release_branch }}"
diff --git a/.github/workflows/misc-update-wishlist-leaderboard.yml b/.github/workflows/misc-update-wishlist-leaderboard.yml
new file mode 100644
index 0000000000000000000000000000000000000000..3261687176746841a57bf2d247aeb6f596310c8b
--- /dev/null
+++ b/.github/workflows/misc-update-wishlist-leaderboard.yml
@@ -0,0 +1,37 @@
+name: Update wishlist leaderboard
+
+on:
+ schedule:
+ # Run every 3 hours
+ - cron: '0 */3 * * *'
+
+permissions:
+ contents: read
+ issues: write
+
+jobs:
+ update-wishlist-leaderboard:
+ if: github.repository == 'paritytech/polkadot-sdk'
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ - name: Set up Python
+ uses: actions/setup-python@v5
+ with:
+ python-version: '3.x'
+ - name: Install dependencies
+ run: |
+ python -m pip install --upgrade pip
+ pip install PyGithub
+ - name: Update developer wishlist
+ env:
+ GH_TOKEN: ${{ github.token }}
+ WISHLIST_REPOSITORY: "paritytech/polkadot-sdk"
+ WISHLIST_ISSUE_NUMBER: "3900"
+ run: python .github/scripts/update-wishlist-leaderboard.py
+ - name: Update user wishlist
+ env:
+ GH_TOKEN: ${{ github.token }}
+ WISHLIST_REPOSITORY: "paritytech/polkadot-sdk"
+ WISHLIST_ISSUE_NUMBER: "3901"
+ run: python .github/scripts/update-wishlist-leaderboard.py
diff --git a/.github/workflows/publish-check-crates.yml b/.github/workflows/publish-check-crates.yml
index 33cf9316920048c65c70376557586d905fd7c9a6..a5af041185728a3bba5bb9379d105a44efe46b29 100644
--- a/.github/workflows/publish-check-crates.yml
+++ b/.github/workflows/publish-check-crates.yml
@@ -8,11 +8,15 @@ on:
types: [opened, synchronize, reopened, ready_for_review]
merge_group:
+concurrency:
+ group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+ cancel-in-progress: true
+
jobs:
check-publish:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Rust Cache
uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2.7.3
@@ -20,7 +24,7 @@ jobs:
cache-on-failure: true
- name: install parity-publish
- run: cargo install parity-publish@0.6.0
+ run: cargo install parity-publish@0.8.0 --locked -q
- name: parity-publish check
run: parity-publish --color always check --allow-unpublished
diff --git a/.github/workflows/publish-claim-crates.yml b/.github/workflows/publish-claim-crates.yml
index 08c50638267ba3be596b5b563433fccf28c2652b..f9bc6ce4daeaa8b3c2f4ce9341fe03d5f9247188 100644
--- a/.github/workflows/publish-claim-crates.yml
+++ b/.github/workflows/publish-claim-crates.yml
@@ -10,7 +10,7 @@ jobs:
runs-on: ubuntu-latest
environment: master
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
- name: Rust Cache
uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2.7.3
@@ -18,7 +18,7 @@ jobs:
cache-on-failure: true
- name: install parity-publish
- run: cargo install parity-publish@0.6.0
+ run: cargo install parity-publish@0.8.0 --locked -q
- name: parity-publish claim
env:
diff --git a/.github/workflows/publish-subsystem-benchmarks.yml b/.github/workflows/publish-subsystem-benchmarks.yml
deleted file mode 100644
index 1a726b669e9094e8be53ef5a1ddb1b3198210d33..0000000000000000000000000000000000000000
--- a/.github/workflows/publish-subsystem-benchmarks.yml
+++ /dev/null
@@ -1,55 +0,0 @@
-# The actions takes json file as input and runs github-action-benchmark for it.
-
-on:
- workflow_dispatch:
- inputs:
- benchmark-data-dir-path:
- description: "Path to the benchmark data directory"
- required: true
- type: string
- output-file-path:
- description: "Path to the benchmark data file"
- required: true
- type: string
-
-jobs:
- subsystem-benchmarks:
- runs-on: ubuntu-latest
- environment: subsystem-benchmarks
- steps:
- - name: Validate inputs
- run: |
- echo "${{ github.event.inputs.benchmark-data-dir-path }}" | grep -P '^[a-z\-]'
- echo "${{ github.event.inputs.output-file-path }}" | grep -P '^[a-z\-]+\.json'
-
- - name: Checkout Sources
- uses: actions/checkout@v4.1.2
- with:
- fetch-depth: 0
- ref: "gh-pages"
-
- - name: Copy bench results
- id: step_one
- run: |
- cp bench/gitlab/${{ github.event.inputs.output-file-path }} ${{ github.event.inputs.output-file-path }}
-
- - name: Switch branch
- id: step_two
- run: |
- git checkout master --
-
- - uses: actions/create-github-app-token@v1
- id: app-token
- with:
- app-id: ${{ secrets.POLKADOTSDK_GHPAGES_APP_ID }}
- private-key: ${{ secrets.POLKADOTSDK_GHPAGES_APP_KEY }}
-
- - name: Store benchmark result
- uses: benchmark-action/github-action-benchmark@v1
- with:
- tool: "customSmallerIsBetter"
- name: ${{ github.event.inputs.benchmark-data-dir-path }}
- output-file-path: ${{ github.event.inputs.output-file-path }}
- benchmark-data-dir-path: "bench/${{ github.event.inputs.benchmark-data-dir-path }}"
- github-token: ${{ steps.app-token.outputs.token }}
- auto-push: true
diff --git a/.github/workflows/release-10_rc-automation.yml b/.github/workflows/release-10_rc-automation.yml
index 7231a8b75886d04ce18bb89fcef99029e3ab14c6..195c14dbd5ab9a102787221f19cecc6319bf46af 100644
--- a/.github/workflows/release-10_rc-automation.yml
+++ b/.github/workflows/release-10_rc-automation.yml
@@ -1,13 +1,18 @@
name: Release - RC automation
on:
- push:
- branches:
- # Catches release-polkadot-v1.2.3, release-v1.2.3-rc1, etc
- - release-v[0-9]+.[0-9]+.[0-9]+*
- - release-cumulus-v[0-9]+*
- - release-polkadot-v[0-9]+*
+ # TODO: Activate it and delete old branches patterns, when the release process from stable is setteled
+ #push:
+ # branches:
+ # # Catches release-polkadot-v1.2.3, release-v1.2.3-rc1, etc
+ # - release-v[0-9]+.[0-9]+.[0-9]+*
+ # - release-cumulus-v[0-9]+*
+ # - release-polkadot-v[0-9]+*
+ # - stable
workflow_dispatch:
+ inputs:
+ version:
+ description: Current release/rc version in format vX.X.X
jobs:
tag_rc:
@@ -21,32 +26,23 @@ jobs:
steps:
- name: Checkout sources
- uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ uses: actions/checkout@6d193bf28034eafb982f37bd894289fe649468fc # v4.1.7
with:
fetch-depth: 0
- - name: Get release product
- id: get_rel_product
- shell: bash
- run: |
- current_branch=$(git branch --show-current)
- echo "Current branch: $current_branch"
- if [[ "$current_branch" =~ "release-polkadot" ]]; then
- echo "product=polkadot" >> $GITHUB_OUTPUT
- elif [[ "$current_branch" =~ "release-cumulus" ]]; then
- echo "product=polkadot-parachain" >> $GITHUB_OUTPUT
- fi
-
-
- - name: Compute next rc tag for polkadot
- if: ${{ steps.get_rel_product.outputs.product == 'polkadot' }}
- id: compute_tag_polkadot
+ - name: Compute next rc tag
+ # if: ${{ steps.get_rel_product.outputs.product == 'polkadot' }}
+ id: compute_tag
shell: bash
run: |
. ./.github/scripts/common/lib.sh
# Get last rc tag if exists, else set it to {version}-rc1
- version=$(get_version_from_ghref ${GITHUB_REF})
+ if [[ -z "${{ inputs.version }}" ]]; then
+ version=v$(get_polkadot_node_version_from_code)
+ else
+ version=$(filter_version_from_input ${{ inputs.version }})
+ fi
echo "$version"
echo "version=$version" >> $GITHUB_OUTPUT
@@ -61,28 +57,6 @@ jobs:
echo "first_rc=true" >> $GITHUB_OUTPUT
fi
- - name: Compute next rc tag for polkadot-parachain
- if: ${{ steps.get_rel_product.outputs.product == 'polkadot-parachain' }}
- id: compute_tag_cumulus
- shell: bash
- run: |
- . ./.github/scripts/common/lib.sh
-
- # Get last rc tag if exists, else set it to polkadot-parachains-{version}-rc1
- version=$(get_version_from_ghref ${GITHUB_REF})
- echo "$version"
- echo "version=$version" >> $GITHUB_OUTPUT
-
- last_rc=$(get_latest_rc_tag $version polkadot-parachain)
- if [ -n "$last_rc" ]; then
- suffix=$(increment_rc_tag $last_rc)
- echo "new_tag=polkadot-parachains-$version-rc$suffix" >> $GITHUB_OUTPUT
- echo "first_rc=false" >> $GITHUB_OUTPUT
- else
- echo "new_tag=polkadot-parachain-$version-rc1" >> $GITHUB_OUTPUT
- echo "first_rc=true" >> $GITHUB_OUTPUT
- fi
-
- name: Apply new tag
uses: tvdias/github-tagger@ed7350546e3e503b5e942dffd65bc8751a95e49d # v0.0.2
with:
@@ -90,17 +64,7 @@ jobs:
# https://docs.github.com/en/actions/reference/events-that-trigger-workflows#triggering-new-workflows-using-a-personal-access-token
# RELEASE_BRANCH_TOKEN requires public_repo OAuth scope
repo-token: "${{ secrets.RELEASE_BRANCH_TOKEN }}"
- tag: ${{ steps.compute_tag_polkadot.outputs.new_tag || steps.compute_tag_cumulus.outputs.new_tag }}
-
- # - id: create-issue
- # uses: JasonEtco/create-an-issue@e27dddc79c92bc6e4562f268fffa5ed752639abd # v2.9.1
- # # Only create the issue if it's the first release candidate
- # if: steps.compute_tag.outputs.first_rc == 'true'
- # env:
- # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- # VERSION: ${{ steps.compute_tag.outputs.version }}
- # with:
- # filename: .github/ISSUE_TEMPLATE/release.md
+ tag: ${{ steps.compute_tag.outputs.new_tag }}
- name: Send Matrix message to ${{ matrix.channel.name }}
uses: s3krit/matrix-message-action@70ad3fb812ee0e45ff8999d6af11cafad11a6ecf # v0.0.3
@@ -110,4 +74,4 @@ jobs:
access_token: ${{ secrets.RELEASENOTES_MATRIX_V2_ACCESS_TOKEN }}
server: m.parity.io
message: |
- Release process for polkadot ${{ steps.compute_tag_polkadot.outputs.new_tag || steps.compute_tag_cumulus.outputs.new_tag }} has been started."]
edition = "2021"
-repository = "https://github.com/paritytech/polkadot-sdk.git"
+homepage = "https://paritytech.github.io/polkadot-sdk/"
license = "GPL-3.0-only"
-homepage = "https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/index.html"
+repository = "https://github.com/paritytech/polkadot-sdk.git"
[workspace]
resolver = "2"
@@ -61,6 +61,7 @@ members = [
"bridges/snowbridge/primitives/router",
"bridges/snowbridge/runtime/runtime-common",
"bridges/snowbridge/runtime/test-common",
+ "cumulus/bin/pov-validator",
"cumulus/client/cli",
"cumulus/client/collator",
"cumulus/client/consensus/aura",
@@ -90,6 +91,8 @@ members = [
"cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo",
"cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend",
"cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend",
+ "cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo",
+ "cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend",
"cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo",
"cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend",
"cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal",
@@ -104,6 +107,8 @@ members = [
"cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo",
"cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend",
"cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend",
+ "cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo",
+ "cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend",
"cumulus/parachains/integration-tests/emulated/tests/people/people-rococo",
"cumulus/parachains/integration-tests/emulated/tests/people/people-westend",
"cumulus/parachains/pallets/collective-content",
@@ -131,6 +136,7 @@ members = [
"cumulus/parachains/runtimes/testing/penpal",
"cumulus/parachains/runtimes/testing/rococo-parachain",
"cumulus/polkadot-parachain",
+ "cumulus/polkadot-parachain/polkadot-parachain-lib",
"cumulus/primitives/aura",
"cumulus/primitives/core",
"cumulus/primitives/parachain-inherent",
@@ -389,6 +395,11 @@ members = [
"substrate/frame/recovery",
"substrate/frame/referenda",
"substrate/frame/remark",
+ "substrate/frame/revive",
+ "substrate/frame/revive/fixtures",
+ "substrate/frame/revive/mock-network",
+ "substrate/frame/revive/proc-macro",
+ "substrate/frame/revive/uapi",
"substrate/frame/root-offences",
"substrate/frame/root-testing",
"substrate/frame/safe-mode",
@@ -517,7 +528,6 @@ members = [
"substrate/utils/prometheus",
"substrate/utils/substrate-bip39",
"substrate/utils/wasm-builder",
- "templates/minimal",
"templates/minimal/node",
"templates/minimal/pallets/template",
"templates/minimal/runtime",
@@ -527,42 +537,46 @@ members = [
"templates/solochain/node",
"templates/solochain/pallets/template",
"templates/solochain/runtime",
+ "templates/zombienet",
"umbrella",
]
default-members = [
+ "cumulus/polkadot-parachain",
"polkadot",
"substrate/bin/node/cli",
]
[workspace.lints.rust]
suspicious_double_ref_op = { level = "allow", priority = 2 }
+# `substrate_runtime` is a common `cfg` condition name used in the repo.
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(substrate_runtime)'] }
[workspace.lints.clippy]
all = { level = "allow", priority = 0 }
-correctness = { level = "warn", priority = 1 }
+bind_instead_of_map = { level = "allow", priority = 2 } # stylistic
+borrowed-box = { level = "allow", priority = 2 } # Reasonable to fix this one
complexity = { level = "warn", priority = 1 }
+correctness = { level = "warn", priority = 1 }
+default_constructed_unit_structs = { level = "allow", priority = 2 } # stylistic
+derivable_impls = { level = "allow", priority = 2 } # false positives
+eq_op = { level = "allow", priority = 2 } # In tests we test equality.
+erasing_op = { level = "allow", priority = 2 } # E.g. 0 * DOLLARS
+extra-unused-type-parameters = { level = "allow", priority = 2 } # stylistic
+identity-op = { level = "allow", priority = 2 } # One case where we do 0 +
if-same-then-else = { level = "allow", priority = 2 }
-zero-prefixed-literal = { level = "allow", priority = 2 } # 00_1000_000
-type_complexity = { level = "allow", priority = 2 } # raison d'etre
+needless-lifetimes = { level = "allow", priority = 2 } # generated code
+needless_option_as_deref = { level = "allow", priority = 2 } # false positives
nonminimal-bool = { level = "allow", priority = 2 } # maybe
-borrowed-box = { level = "allow", priority = 2 } # Reasonable to fix this one
+option-map-unit-fn = { level = "allow", priority = 2 } # stylistic
+stable_sort_primitive = { level = "allow", priority = 2 } # prefer stable sort
too-many-arguments = { level = "allow", priority = 2 } # (Turning this on would lead to)
-needless-lifetimes = { level = "allow", priority = 2 } # generated code
+type_complexity = { level = "allow", priority = 2 } # raison d'etre
+unit_arg = { level = "allow", priority = 2 } # stylistic
unnecessary_cast = { level = "allow", priority = 2 } # Types may change
-identity-op = { level = "allow", priority = 2 } # One case where we do 0 +
useless_conversion = { level = "allow", priority = 2 } # Types may change
-unit_arg = { level = "allow", priority = 2 } # stylistic
-option-map-unit-fn = { level = "allow", priority = 2 } # stylistic
-bind_instead_of_map = { level = "allow", priority = 2 } # stylistic
-erasing_op = { level = "allow", priority = 2 } # E.g. 0 * DOLLARS
-eq_op = { level = "allow", priority = 2 } # In tests we test equality.
while_immutable_condition = { level = "allow", priority = 2 } # false positives
-needless_option_as_deref = { level = "allow", priority = 2 } # false positives
-derivable_impls = { level = "allow", priority = 2 } # false positives
-stable_sort_primitive = { level = "allow", priority = 2 } # prefer stable sort
-extra-unused-type-parameters = { level = "allow", priority = 2 } # stylistic
-default_constructed_unit_structs = { level = "allow", priority = 2 } # stylistic
+zero-prefixed-literal = { level = "allow", priority = 2 } # 00_1000_000
[workspace.dependencies]
Inflector = { version = "0.11.4" }
@@ -571,8 +585,7 @@ ahash = { version = "0.8.2" }
alloy-primitives = { version = "0.4.2", default-features = false }
alloy-sol-types = { version = "0.4.2", default-features = false }
always-assert = { version = "0.1" }
-ansi_term = { version = "0.12.1" }
-anyhow = { version = "1.0.81" }
+anyhow = { version = "1.0.81", default-features = false }
aquamarine = { version = "0.5.0" }
arbitrary = { version = "1.3.2" }
ark-bls12-377 = { version = "0.4.0", default-features = false }
@@ -589,7 +602,7 @@ ark-ed-on-bls12-381-bandersnatch-ext = { version = "0.4.1", default-features = f
ark-scale = { version = "0.0.12", default-features = false }
array-bytes = { version = "6.2.2", default-features = false }
arrayvec = { version = "0.7.4" }
-assert_cmd = { version = "2.0.10" }
+assert_cmd = { version = "2.0.14" }
assert_matches = { version = "1.5.0" }
asset-hub-rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo" }
asset-hub-rococo-runtime = { path = "cumulus/parachains/runtimes/assets/asset-hub-rococo", default-features = false }
@@ -602,14 +615,14 @@ async-std = { version = "1.9.0" }
async-trait = { version = "0.1.79" }
asynchronous-codec = { version = "0.6" }
backoff = { version = "0.4" }
-backtrace = { version = "0.3.64" }
+backtrace = { version = "0.3.71" }
binary-merkle-tree = { path = "substrate/utils/binary-merkle-tree", default-features = false }
bincode = { version = "1.3.3" }
bip39 = { version = "2.0.0" }
bitflags = { version = "1.3.2" }
bitvec = { version = "1.0.1", default-features = false }
blake2 = { version = "0.10.4", default-features = false }
-blake2b_simd = { version = "1.0.1", default-features = false }
+blake2b_simd = { version = "1.0.2", default-features = false }
blake3 = { version = "1.5" }
bounded-collections = { version = "0.2.0", default-features = false }
bounded-vec = { version = "0.7" }
@@ -642,7 +655,7 @@ bridge-hub-test-utils = { path = "cumulus/parachains/runtimes/bridge-hubs/test-u
bridge-hub-westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend" }
bridge-hub-westend-runtime = { path = "cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend", default-features = false }
bridge-runtime-common = { path = "bridges/bin/runtime-common", default-features = false }
-bs58 = { version = "0.5.0", default-features = false }
+bs58 = { version = "0.5.1", default-features = false }
build-helper = { version = "0.1.1" }
byte-slice-cast = { version = "1.2.1", default-features = false }
byteorder = { version = "1.3.2", default-features = false }
@@ -654,20 +667,22 @@ chain-spec-builder = { path = "substrate/bin/utils/chain-spec-builder", default-
chain-spec-guide-runtime = { path = "docs/sdk/src/reference_docs/chain_spec_runtime" }
chrono = { version = "0.4.31" }
cid = { version = "0.9.0" }
-clap = { version = "4.5.3" }
+clap = { version = "4.5.10" }
clap-num = { version = "1.0.2" }
-clap_complete = { version = "4.0.2" }
+clap_complete = { version = "4.5.13" }
coarsetime = { version = "0.1.22" }
codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
collectives-westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend" }
collectives-westend-runtime = { path = "cumulus/parachains/runtimes/collectives/collectives-westend" }
-color-eyre = { version = "0.6.1", default-features = false }
+color-eyre = { version = "0.6.3", default-features = false }
color-print = { version = "0.3.4" }
colored = { version = "2.0.4" }
comfy-table = { version = "7.1.0", default-features = false }
console = { version = "0.15.8" }
contracts-rococo-runtime = { path = "cumulus/parachains/runtimes/contracts/contracts-rococo" }
+coretime-rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo" }
coretime-rococo-runtime = { path = "cumulus/parachains/runtimes/coretime/coretime-rococo" }
+coretime-westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend" }
coretime-westend-runtime = { path = "cumulus/parachains/runtimes/coretime/coretime-westend" }
cpu-time = { version = "1.0.0" }
criterion = { version = "0.5.1", default-features = false }
@@ -720,8 +735,7 @@ ed25519-zebra = { version = "4.0.3", default-features = false }
either = { version = "1.8.1", default-features = false }
emulated-integration-tests-common = { path = "cumulus/parachains/integration-tests/emulated/common", default-features = false }
enumflags2 = { version = "0.7.7" }
-enumn = { version = "0.1.12" }
-env_logger = { version = "0.11.3" }
+enumn = { version = "0.1.13" }
environmental = { version = "1.1.4", default-features = false }
equivocation-detector = { path = "bridges/relays/equivocation" }
ethabi = { version = "1.0.0", default-features = false, package = "ethabi-decode" }
@@ -797,9 +811,11 @@ is-terminal = { version = "0.4.9" }
is_executable = { version = "1.0.1" }
isahc = { version = "1.2" }
itertools = { version = "0.11" }
+jemalloc_pprof = { version = "0.4" }
+jobserver = { version = "0.1.26" }
jsonpath_lib = { version = "0.3" }
-jsonrpsee = { version = "0.23.2" }
-jsonrpsee-core = { version = "0.23.2" }
+jsonrpsee = { version = "0.24.3" }
+jsonrpsee-core = { version = "0.24.3" }
k256 = { version = "0.13.3", default-features = false }
kitchensink-runtime = { path = "substrate/bin/node/runtime" }
kvdb = { version = "0.13.0" }
@@ -807,19 +823,19 @@ kvdb-memorydb = { version = "0.13.0" }
kvdb-rocksdb = { version = "0.19.0" }
kvdb-shared-tests = { version = "0.11.0" }
landlock = { version = "0.3.0" }
-lazy_static = { version = "1.4.0" }
-libc = { version = "0.2.153" }
+lazy_static = { version = "1.5.0" }
+libc = { version = "0.2.155" }
libfuzzer-sys = { version = "0.4" }
libp2p = { version = "0.52.4" }
-libp2p-identity = { version = "0.2.3" }
+libp2p-identity = { version = "0.2.9" }
libsecp256k1 = { version = "0.7.0", default-features = false }
linked-hash-map = { version = "0.5.4" }
linked_hash_set = { version = "0.1.4" }
linregress = { version = "0.5.1" }
lite-json = { version = "0.2.0", default-features = false }
-litep2p = { version = "0.6.2" }
-log = { version = "0.4.21", default-features = false }
-macro_magic = { version = "0.5.0" }
+litep2p = { version = "0.7.0", features = ["websocket"] }
+log = { version = "0.4.22", default-features = false }
+macro_magic = { version = "0.5.1" }
maplit = { version = "1.0.2" }
memmap2 = { version = "0.9.3" }
memory-db = { version = "0.32.0", default-features = false }
@@ -855,7 +871,7 @@ num-rational = { version = "0.4.1" }
num-traits = { version = "0.2.17", default-features = false }
num_cpus = { version = "1.13.1" }
once_cell = { version = "1.19.0" }
-orchestra = { version = "0.3.5", default-features = false }
+orchestra = { version = "0.4.0", default-features = false }
pallet-alliance = { path = "substrate/frame/alliance", default-features = false }
pallet-asset-conversion = { path = "substrate/frame/asset-conversion", default-features = false }
pallet-asset-conversion-ops = { path = "substrate/frame/asset-conversion/ops", default-features = false }
@@ -885,7 +901,7 @@ pallet-collator-selection = { path = "cumulus/pallets/collator-selection", defau
pallet-collective = { path = "substrate/frame/collective", default-features = false }
pallet-collective-content = { path = "cumulus/parachains/pallets/collective-content", default-features = false }
pallet-contracts = { path = "substrate/frame/contracts", default-features = false }
-pallet-contracts-fixtures = { path = "substrate/frame/contracts/fixtures" }
+pallet-contracts-fixtures = { path = "substrate/frame/contracts/fixtures", default-features = false }
pallet-contracts-mock-network = { default-features = false, path = "substrate/frame/contracts/mock-network" }
pallet-contracts-proc-macro = { path = "substrate/frame/contracts/proc-macro", default-features = false }
pallet-contracts-uapi = { path = "substrate/frame/contracts/uapi", default-features = false }
@@ -941,6 +957,11 @@ pallet-ranked-collective = { path = "substrate/frame/ranked-collective", default
pallet-recovery = { path = "substrate/frame/recovery", default-features = false }
pallet-referenda = { path = "substrate/frame/referenda", default-features = false }
pallet-remark = { default-features = false, path = "substrate/frame/remark" }
+pallet-revive = { path = "substrate/frame/revive", default-features = false }
+pallet-revive-fixtures = { path = "substrate/frame/revive/fixtures", default-features = false }
+pallet-revive-mock-network = { default-features = false, path = "substrate/frame/revive/mock-network" }
+pallet-revive-proc-macro = { path = "substrate/frame/revive/proc-macro", default-features = false }
+pallet-revive-uapi = { path = "substrate/frame/revive/uapi", default-features = false }
pallet-root-offences = { default-features = false, path = "substrate/frame/root-offences" }
pallet-root-testing = { path = "substrate/frame/root-testing", default-features = false }
pallet-safe-mode = { default-features = false, path = "substrate/frame/safe-mode" }
@@ -986,7 +1007,7 @@ parity-util-mem = { version = "0.12.0" }
parity-wasm = { version = "0.45.0" }
parking_lot = { version = "0.12.1", default-features = false }
partial_sort = { version = "0.2.0" }
-paste = { version = "1.0.14", default-features = false }
+paste = { version = "1.0.15", default-features = false }
pbkdf2 = { version = "0.12.2", default-features = false }
penpal-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal" }
penpal-runtime = { path = "cumulus/parachains/runtimes/testing/penpal" }
@@ -1034,6 +1055,7 @@ polkadot-node-subsystem-test-helpers = { path = "polkadot/node/subsystem-test-he
polkadot-node-subsystem-types = { path = "polkadot/node/subsystem-types", default-features = false }
polkadot-node-subsystem-util = { path = "polkadot/node/subsystem-util", default-features = false }
polkadot-overseer = { path = "polkadot/node/overseer", default-features = false }
+polkadot-parachain-lib = { path = "cumulus/polkadot-parachain/polkadot-parachain-lib", default-features = false }
polkadot-parachain-primitives = { path = "polkadot/parachain", default-features = false }
polkadot-primitives = { path = "polkadot/primitives", default-features = false }
polkadot-primitives-test-helpers = { path = "polkadot/primitives/test-helpers" }
@@ -1050,7 +1072,7 @@ polkadot-subsystem-bench = { path = "polkadot/node/subsystem-bench" }
polkadot-test-client = { path = "polkadot/node/test/client" }
polkadot-test-runtime = { path = "polkadot/runtime/test-runtime" }
polkadot-test-service = { path = "polkadot/node/test/service" }
-polkavm = "0.9.3"
+polkavm = { version = "0.9.3", default-features = false }
polkavm-derive = "0.9.1"
polkavm-linker = "0.9.2"
portpicker = { version = "0.1.1" }
@@ -1058,7 +1080,7 @@ pretty_assertions = { version = "1.3.0" }
primitive-types = { version = "0.12.1", default-features = false }
proc-macro-crate = { version = "3.0.0" }
proc-macro-warning = { version = "1.0.0", default-features = false }
-proc-macro2 = { version = "1.0.64" }
+proc-macro2 = { version = "1.0.86" }
procfs = { version = "0.16.0" }
prometheus = { version = "0.13.0", default-features = false }
prometheus-endpoint = { path = "substrate/utils/prometheus", default-features = false, package = "substrate-prometheus-endpoint" }
@@ -1069,7 +1091,7 @@ pyroscope = { version = "0.5.7" }
pyroscope_pprofrs = { version = "0.2.7" }
quick_cache = { version = "0.3" }
quickcheck = { version = "1.0.3", default-features = false }
-quote = { version = "1.0.33" }
+quote = { version = "1.0.37" }
rand = { version = "0.8.5", default-features = false }
rand_chacha = { version = "0.3.1", default-features = false }
rand_core = { version = "0.6.2" }
@@ -1077,7 +1099,7 @@ rand_distr = { version = "0.4.3" }
rand_pcg = { version = "0.3.1" }
rayon = { version = "1.5.1" }
rbtag = { version = "0.3" }
-ref-cast = { version = "1.0.0" }
+ref-cast = { version = "1.0.23" }
regex = { version = "1.10.2" }
relay-substrate-client = { path = "bridges/relays/client-substrate" }
relay-utils = { path = "bridges/relays/utils" }
@@ -1095,7 +1117,7 @@ rstest = { version = "0.18.2" }
rustc-hash = { version = "1.1.0" }
rustc-hex = { version = "2.1.0", default-features = false }
rustix = { version = "0.36.7", default-features = false }
-rustversion = { version = "1.0.6" }
+rustversion = { version = "1.0.17" }
rusty-fork = { version = "0.3.0", default-features = false }
safe-mix = { version = "1.0", default-features = false }
sc-allocator = { path = "substrate/client/allocator", default-features = false }
@@ -1157,17 +1179,17 @@ sc-transaction-pool-api = { path = "substrate/client/transaction-pool/api", defa
sc-utils = { path = "substrate/client/utils", default-features = false }
scale-info = { version = "2.11.1", default-features = false }
schemars = { version = "0.8.13", default-features = false }
-schnellru = { version = "0.2.1" }
+schnellru = { version = "0.2.3" }
schnorrkel = { version = "0.11.4", default-features = false }
seccompiler = { version = "0.4.0" }
secp256k1 = { version = "0.28.0", default-features = false }
secrecy = { version = "0.8.0", default-features = false }
seedling-runtime = { path = "cumulus/parachains/runtimes/starters/seedling" }
separator = { version = "0.4.1" }
-serde = { version = "1.0.197", default-features = false }
+serde = { version = "1.0.210", default-features = false }
serde-big-array = { version = "0.3.2" }
serde_derive = { version = "1.0.117" }
-serde_json = { version = "1.0.114", default-features = false }
+serde_json = { version = "1.0.128", default-features = false }
serde_yaml = { version = "0.9" }
serial_test = { version = "2.0.0" }
sha1 = { version = "0.10.6" }
@@ -1254,7 +1276,7 @@ sp-version = { path = "substrate/primitives/version", default-features = false }
sp-version-proc-macro = { path = "substrate/primitives/version/proc-macro", default-features = false }
sp-wasm-interface = { path = "substrate/primitives/wasm-interface", default-features = false }
sp-weights = { path = "substrate/primitives/weights", default-features = false }
-spinners = { version = "4.1.0" }
+spinners = { version = "4.1.1" }
ss58-registry = { version = "1.34.0", default-features = false }
ssz_rs = { version = "0.9.0", default-features = false }
ssz_rs_derive = { version = "0.9.0", default-features = false }
@@ -1276,7 +1298,7 @@ substrate-test-runtime-client = { path = "substrate/test-utils/runtime/client" }
substrate-test-runtime-transaction-pool = { path = "substrate/test-utils/runtime/transaction-pool" }
substrate-test-utils = { path = "substrate/test-utils" }
substrate-wasm-builder = { path = "substrate/utils/wasm-builder", default-features = false }
-syn = { version = "2.0.53" }
+syn = { version = "2.0.65" }
sysinfo = { version = "0.30" }
tar = { version = "0.4" }
tempfile = { version = "3.8.1" }
@@ -1300,7 +1322,7 @@ tokio-stream = { version = "0.1.14" }
tokio-test = { version = "0.4.2" }
tokio-tungstenite = { version = "0.20.1" }
tokio-util = { version = "0.7.8" }
-toml = { version = "0.8.8" }
+toml = { version = "0.8.12" }
toml_edit = { version = "0.19" }
tower = { version = "0.4.13" }
tower-http = { version = "0.5.2" }
@@ -1311,10 +1333,10 @@ tracing-log = { version = "0.2.0" }
tracing-subscriber = { version = "0.3.18" }
tracking-allocator = { path = "polkadot/node/tracking-allocator", default-features = false, package = "staging-tracking-allocator" }
trie-bench = { version = "0.39.0" }
-trie-db = { version = "0.29.0", default-features = false }
+trie-db = { version = "0.29.1", default-features = false }
trie-root = { version = "0.18.0", default-features = false }
trie-standardmap = { version = "0.16.0" }
-trybuild = { version = "1.0.88" }
+trybuild = { version = "1.0.89" }
tt-call = { version = "1.0.8" }
tuplex = { version = "0.1", default-features = false }
twox-hash = { version = "1.6.3", default-features = false }
@@ -1323,7 +1345,7 @@ url = { version = "2.4.0" }
void = { version = "1.0.2" }
w3f-bls = { version = "0.1.3", default-features = false }
wait-timeout = { version = "0.2" }
-walkdir = { version = "2.4.0" }
+walkdir = { version = "2.5.0" }
wasm-bindgen-test = { version = "0.3.19" }
wasm-instrument = { version = "0.4", default-features = false }
wasm-opt = { version = "0.116" }
@@ -1349,22 +1371,22 @@ zstd = { version = "0.12.4", default-features = false }
[profile.release]
# Polkadot runtime requires unwinding.
-panic = "unwind"
opt-level = 3
+panic = "unwind"
# make sure dev builds with backtrace do not slow us down
[profile.dev.package.backtrace]
inherits = "release"
[profile.production]
+codegen-units = 1
inherits = "release"
lto = true
-codegen-units = 1
[profile.testnet]
-inherits = "release"
debug = 1 # debug symbols are useful for profilers
debug-assertions = true
+inherits = "release"
overflow-checks = true
# The list of dependencies below (which can be both direct and indirect dependencies) are crates
diff --git a/README.md b/README.md
index 92901d070db0854dd4b1daef8c3ed7a3fd3893f2..702c853684cda347fe6c9f7ec7d2e6fcedc25ae6 100644
--- a/README.md
+++ b/README.md
@@ -10,10 +10,7 @@
forks](https://img.shields.io/github/forks/paritytech/polkadot-sdk)
-[](https://substrate.stackexchange.com/)  
-
-
-
+[](https://substrate.stackexchange.com/)   
> The Polkadot SDK repository provides all the components needed to start building on the
> [Polkadot](https://polkadot.network) network, a multi-chain blockchain platform that enables
@@ -21,6 +18,12 @@ forks](https://img.shields.io/github/forks/paritytech/polkadot-sdk)
+## ⚡ Quickstart
+If you want to get an example node running quickly you can execute the following getting started script:
+```
+curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/scripts/getting-started.sh | bash
+```
+
## 📚 Documentation
* [🦀 rust-docs](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/index.html)
@@ -35,27 +38,15 @@ forks](https://img.shields.io/github/forks/paritytech/polkadot-sdk)
## 🚀 Releases
-> [!NOTE]
-> Our release process is still Work-In-Progress and may not yet reflect the aspired outline
-> here.
-
-The Polkadot-SDK has two release channels: `stable` and `nightly`. Production software is advised to
-only use `stable`. `nightly` is meant for tinkerers to try out the latest features. The detailed
-release process is described in [RELEASE.md](docs/RELEASE.md).
-
-You can use [`psvm`](https://github.com/paritytech/psvm) to manage your Polkadot-SDK dependency
-versions in downstream projects.
-
-### 😌 Stable
-
-`stable` releases have a support duration of **three months**. In this period, the release will not
-have any breaking changes. It will receive bug fixes, security fixes, performance fixes and new
-non-breaking features on a **two week** cadence.
+
+ 
-### 🤠 Nightly
+The Polkadot-SDK is released every three months as a `stableYYMMDD` release. They are supported for
+one year with patches. See the next upcoming versions in the [Release
+Registry](https://github.com/paritytech/release-registry/).
-`nightly` releases are released every night from the `master` branch, potentially with breaking
-changes. They have pre-release version numbers in the format `major.0.0-nightlyYYMMDD`.
+You can use [`psvm`](https://github.com/paritytech/psvm) to update all dependencies to a specific
+version without needing to manually select the correct version for each crate.
## 🛠️ Tooling
diff --git a/bridges/bin/runtime-common/Cargo.toml b/bridges/bin/runtime-common/Cargo.toml
index d69a064aab81a41c946b073f232ebb8c778b9609..b8835d55f0da2ad9a88a94f10539f4312950600a 100644
--- a/bridges/bin/runtime-common/Cargo.toml
+++ b/bridges/bin/runtime-common/Cargo.toml
@@ -12,14 +12,12 @@ workspace = true
[dependencies]
codec = { features = ["derive"], workspace = true }
-hash-db = { workspace = true }
log = { workspace = true }
scale-info = { features = ["derive"], workspace = true }
static_assertions = { optional = true, workspace = true, default-features = true }
tuplex = { workspace = true }
# Bridge dependencies
-
bp-header-chain = { workspace = true }
bp-messages = { workspace = true }
bp-parachains = { workspace = true }
@@ -27,32 +25,32 @@ bp-polkadot-core = { workspace = true }
bp-relayers = { workspace = true }
bp-runtime = { workspace = true }
bp-xcm-bridge-hub = { workspace = true }
-bp-xcm-bridge-hub-router = { workspace = true }
pallet-bridge-grandpa = { workspace = true }
pallet-bridge-messages = { workspace = true }
pallet-bridge-parachains = { workspace = true }
pallet-bridge-relayers = { workspace = true }
# Substrate dependencies
-
frame-support = { workspace = true }
frame-system = { workspace = true }
pallet-transaction-payment = { workspace = true }
pallet-utility = { workspace = true }
-sp-api = { workspace = true }
-sp-core = { workspace = true }
sp-io = { workspace = true }
sp-runtime = { workspace = true }
sp-std = { workspace = true }
-sp-trie = { workspace = true }
+sp-trie = { optional = true, workspace = true }
# Polkadot dependencies
xcm = { workspace = true }
-xcm-builder = { workspace = true }
[dev-dependencies]
-bp-test-utils = { workspace = true, default-features = true }
-pallet-balances = { workspace = true, default-features = true }
+bp-test-utils = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-bridge-messages = { features = [
+ "std",
+ "test-helpers",
+], workspace = true }
+sp-core = { workspace = true }
[features]
default = ["std"]
@@ -63,13 +61,13 @@ std = [
"bp-polkadot-core/std",
"bp-relayers/std",
"bp-runtime/std",
- "bp-xcm-bridge-hub-router/std",
+ "bp-test-utils/std",
"bp-xcm-bridge-hub/std",
"codec/std",
"frame-support/std",
"frame-system/std",
- "hash-db/std",
"log/std",
+ "pallet-balances/std",
"pallet-bridge-grandpa/std",
"pallet-bridge-messages/std",
"pallet-bridge-parachains/std",
@@ -77,26 +75,27 @@ std = [
"pallet-transaction-payment/std",
"pallet-utility/std",
"scale-info/std",
- "sp-api/std",
"sp-core/std",
"sp-io/std",
"sp-runtime/std",
"sp-std/std",
"sp-trie/std",
"tuplex/std",
- "xcm-builder/std",
"xcm/std",
]
runtime-benchmarks = [
+ "bp-runtime/test-helpers",
"frame-support/runtime-benchmarks",
"frame-system/runtime-benchmarks",
"pallet-balances/runtime-benchmarks",
"pallet-bridge-grandpa/runtime-benchmarks",
"pallet-bridge-messages/runtime-benchmarks",
+ "pallet-bridge-messages/test-helpers",
"pallet-bridge-parachains/runtime-benchmarks",
"pallet-bridge-relayers/runtime-benchmarks",
"pallet-utility/runtime-benchmarks",
"sp-runtime/runtime-benchmarks",
- "xcm-builder/runtime-benchmarks",
+ "sp-trie",
]
integrity-test = ["static_assertions"]
+test-helpers = ["bp-runtime/test-helpers", "sp-trie"]
diff --git a/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs b/bridges/bin/runtime-common/src/extensions.rs
similarity index 76%
rename from bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
rename to bridges/bin/runtime-common/src/extensions.rs
index df75092af6e8b89fb76003cf0bfff508214ea825..dc7e14de28f311817b7bced78e62ff1b5b037b1d 100644
--- a/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
+++ b/bridges/bin/runtime-common/src/extensions.rs
@@ -18,23 +18,20 @@
//! obsolete (duplicated) data or do not pass some additional pallet-specific
//! checks.
-use crate::{
- extensions::refund_relayer_extension::RefundableParachainId,
- messages_call_ext::MessagesCallSubType,
-};
+use bp_parachains::SubmitParachainHeadsInfo;
use bp_relayers::ExplicitOrAccountParams;
use bp_runtime::Parachain;
use pallet_bridge_grandpa::{
BridgedBlockNumber, CallSubType as GrandpaCallSubType, SubmitFinalityProofHelper,
};
-use pallet_bridge_parachains::{
- CallSubType as ParachainsCallSubtype, SubmitParachainHeadsHelper, SubmitParachainHeadsInfo,
-};
+use pallet_bridge_messages::CallSubType as MessagesCallSubType;
+use pallet_bridge_parachains::{CallSubType as ParachainsCallSubtype, SubmitParachainHeadsHelper};
use pallet_bridge_relayers::Pallet as RelayersPallet;
use sp_runtime::{
- traits::{Get, PhantomData, UniqueSaturatedInto},
+ traits::{Get, UniqueSaturatedInto},
transaction_validity::{TransactionPriority, TransactionValidity, ValidTransactionBuilder},
};
+use sp_std::marker::PhantomData;
// Re-export to avoid include tuplex dependency everywhere.
#[doc(hidden)]
@@ -126,17 +123,27 @@ where
/// `(BundledHeaderNumber - 1 - BestKnownHeaderNumber) * Priority::get()`.
/// The boost is only applied if submitter has active registration in the relayers
/// pallet.
-pub struct CheckAndBoostBridgeParachainsTransactions(
- PhantomData<(T, RefPara, Priority, SlashAccount)>,
-);
-
-impl, SlashAccount: Get>
- BridgeRuntimeFilterCall
- for CheckAndBoostBridgeParachainsTransactions
+pub struct CheckAndBoostBridgeParachainsTransactions<
+ T,
+ ParachainsInstance,
+ Para,
+ Priority,
+ SlashAccount,
+>(PhantomData<(T, ParachainsInstance, Para, Priority, SlashAccount)>);
+
+impl<
+ T,
+ ParachainsInstance,
+ Para,
+ Priority: Get,
+ SlashAccount: Get,
+ > BridgeRuntimeFilterCall
+ for CheckAndBoostBridgeParachainsTransactions
where
- T: pallet_bridge_relayers::Config + pallet_bridge_parachains::Config,
- RefPara: RefundableParachainId,
- T::RuntimeCall: ParachainsCallSubtype,
+ T: pallet_bridge_relayers::Config + pallet_bridge_parachains::Config,
+ ParachainsInstance: 'static,
+ Para: Parachain,
+ T::RuntimeCall: ParachainsCallSubtype,
{
// bridged header number, bundled in transaction
type ToPostDispatch = Option;
@@ -145,10 +152,10 @@ where
who: &T::AccountId,
call: &T::RuntimeCall,
) -> (Self::ToPostDispatch, TransactionValidity) {
- match ParachainsCallSubtype::::check_obsolete_submit_parachain_heads(
+ match ParachainsCallSubtype::::check_obsolete_submit_parachain_heads(
call,
) {
- Ok(Some(our_tx)) if our_tx.base.para_id.0 == RefPara::BridgedChain::PARACHAIN_ID => {
+ Ok(Some(our_tx)) if our_tx.base.para_id.0 == Para::PARACHAIN_ID => {
let to_post_dispatch = Some(our_tx.base);
let total_priority_boost =
compute_priority_boost::(&who, our_tx.improved_by);
@@ -167,7 +174,7 @@ where
let Some(update) = maybe_update else { return };
// we are only interested in failed or unneeded transactions
let has_failed = has_failed ||
- !SubmitParachainHeadsHelper::::was_successful(&update);
+ !SubmitParachainHeadsHelper::::was_successful(&update);
if !has_failed {
return
@@ -275,7 +282,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
type Pre = (
$account_id,
( $(
- <$filter_call as $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ <$filter_call as $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::ToPostDispatch,
@@ -302,7 +309,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
$(
let (from_validate, call_filter_validity) = <
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
Self::AccountId,
$call,
>>::validate(&who, call);
@@ -319,12 +326,13 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
info: &sp_runtime::traits::DispatchInfoOf,
len: usize,
) -> Result {
- use $crate::extensions::check_obsolete_extension::__private::tuplex::PushBack;
+ use $crate::extensions::__private::tuplex::PushBack;
+
let to_post_dispatch = ();
$(
let (from_validate, call_filter_validity) = <
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::validate(&relayer, call);
@@ -342,14 +350,15 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
len: usize,
result: &sp_runtime::DispatchResult,
) -> Result<(), sp_runtime::transaction_validity::TransactionValidityError> {
- use $crate::extensions::check_obsolete_extension::__private::tuplex::PopFront;
+ use $crate::extensions::__private::tuplex::PopFront;
+
let Some((relayer, to_post_dispatch)) = to_post_dispatch else { return Ok(()) };
let has_failed = result.is_err();
$(
let (item, to_post_dispatch) = to_post_dispatch.pop_front();
<
$filter_call as
- $crate::extensions::check_obsolete_extension::BridgeRuntimeFilterCall<
+ $crate::extensions::BridgeRuntimeFilterCall<
$account_id,
$call,
>>::post_dispatch(&relayer, has_failed, item);
@@ -363,25 +372,37 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
#[cfg(test)]
mod tests {
use super::*;
- use crate::{
- extensions::refund_relayer_extension::{
- tests::{
- initialize_environment, relayer_account_at_this_chain,
- submit_parachain_head_call_ex, submit_relay_header_call_ex,
- },
- RefundableParachain,
- },
- mock::*,
- };
- use bp_polkadot_core::parachains::ParaId;
+ use crate::mock::*;
+ use bp_header_chain::StoredHeaderDataBuilder;
+ use bp_messages::{InboundLaneData, LaneId, MessageNonce, OutboundLaneData};
+ use bp_parachains::{BestParaHeadHash, ParaInfo};
+ use bp_polkadot_core::parachains::{ParaHeadsProof, ParaId};
+ use bp_relayers::{RewardsAccountOwner, RewardsAccountParams};
use bp_runtime::HeaderId;
- use frame_support::{assert_err, assert_ok};
+ use bp_test_utils::{make_default_justification, test_keyring, TEST_GRANDPA_SET_ID};
+ use frame_support::{assert_err, assert_ok, traits::fungible::Mutate};
+ use pallet_bridge_grandpa::{Call as GrandpaCall, StoredAuthoritySet};
+ use pallet_bridge_parachains::Call as ParachainsCall;
use sp_runtime::{
- traits::{ConstU64, SignedExtension},
+ traits::{parameter_types, ConstU64, Header as _, SignedExtension},
transaction_validity::{InvalidTransaction, TransactionValidity, ValidTransaction},
DispatchError,
};
+ parameter_types! {
+ pub MsgProofsRewardsAccount: RewardsAccountParams = RewardsAccountParams::new(
+ test_lane_id(),
+ TEST_BRIDGED_CHAIN_ID,
+ RewardsAccountOwner::ThisChain,
+ );
+ pub MsgDeliveryProofsRewardsAccount: RewardsAccountParams = RewardsAccountParams::new(
+ test_lane_id(),
+ TEST_BRIDGED_CHAIN_ID,
+ RewardsAccountOwner::BridgedChain,
+ );
+ pub TestLaneId: LaneId = test_lane_id();
+ }
+
pub struct MockCall {
data: u32,
}
@@ -455,6 +476,103 @@ mod tests {
}
}
+ fn test_lane_id() -> LaneId {
+ LaneId::new(1, 2)
+ }
+
+ fn initial_balance_of_relayer_account_at_this_chain() -> ThisChainBalance {
+ let test_stake: ThisChainBalance = TestStake::get();
+ ExistentialDeposit::get().saturating_add(test_stake * 100)
+ }
+
+ // in tests, the following accounts are equal (because of how `into_sub_account_truncating`
+ // works)
+
+ fn delivery_rewards_account() -> ThisChainAccountId {
+ TestPaymentProcedure::rewards_account(MsgProofsRewardsAccount::get())
+ }
+
+ fn confirmation_rewards_account() -> ThisChainAccountId {
+ TestPaymentProcedure::rewards_account(MsgDeliveryProofsRewardsAccount::get())
+ }
+
+ fn relayer_account_at_this_chain() -> ThisChainAccountId {
+ 0
+ }
+
+ fn initialize_environment(
+ best_relay_header_number: BridgedChainBlockNumber,
+ parachain_head_at_relay_header_number: BridgedChainBlockNumber,
+ best_message: MessageNonce,
+ ) {
+ let authorities = test_keyring().into_iter().map(|(a, w)| (a.into(), w)).collect();
+ let best_relay_header = HeaderId(best_relay_header_number, BridgedChainHash::default());
+ pallet_bridge_grandpa::CurrentAuthoritySet::::put(
+ StoredAuthoritySet::try_new(authorities, TEST_GRANDPA_SET_ID).unwrap(),
+ );
+ pallet_bridge_grandpa::BestFinalized::::put(best_relay_header);
+ pallet_bridge_grandpa::ImportedHeaders::::insert(
+ best_relay_header.hash(),
+ bp_test_utils::test_header::(0).build(),
+ );
+
+ let para_id = ParaId(BridgedUnderlyingParachain::PARACHAIN_ID);
+ let para_info = ParaInfo {
+ best_head_hash: BestParaHeadHash {
+ at_relay_block_number: parachain_head_at_relay_header_number,
+ head_hash: [parachain_head_at_relay_header_number as u8; 32].into(),
+ },
+ next_imported_hash_position: 0,
+ };
+ pallet_bridge_parachains::ParasInfo::::insert(para_id, para_info);
+
+ let lane_id = test_lane_id();
+ let in_lane_data =
+ InboundLaneData { last_confirmed_nonce: best_message, ..Default::default() };
+ pallet_bridge_messages::InboundLanes::::insert(lane_id, in_lane_data);
+
+ let out_lane_data =
+ OutboundLaneData { latest_received_nonce: best_message, ..Default::default() };
+ pallet_bridge_messages::OutboundLanes::::insert(lane_id, out_lane_data);
+
+ Balances::mint_into(&delivery_rewards_account(), ExistentialDeposit::get()).unwrap();
+ Balances::mint_into(&confirmation_rewards_account(), ExistentialDeposit::get()).unwrap();
+ Balances::mint_into(
+ &relayer_account_at_this_chain(),
+ initial_balance_of_relayer_account_at_this_chain(),
+ )
+ .unwrap();
+ }
+
+ fn submit_relay_header_call(relay_header_number: BridgedChainBlockNumber) -> RuntimeCall {
+ let relay_header = BridgedChainHeader::new(
+ relay_header_number,
+ Default::default(),
+ Default::default(),
+ Default::default(),
+ Default::default(),
+ );
+ let relay_justification = make_default_justification(&relay_header);
+
+ RuntimeCall::BridgeGrandpa(GrandpaCall::submit_finality_proof {
+ finality_target: Box::new(relay_header),
+ justification: relay_justification,
+ })
+ }
+
+ fn submit_parachain_head_call(
+ parachain_head_at_relay_header_number: BridgedChainBlockNumber,
+ ) -> RuntimeCall {
+ RuntimeCall::BridgeParachains(ParachainsCall::submit_parachain_heads {
+ at_relay_block: (parachain_head_at_relay_header_number, BridgedChainHash::default()),
+ parachains: vec![(
+ ParaId(BridgedUnderlyingParachain::PARACHAIN_ID),
+ [parachain_head_at_relay_header_number as u8; 32].into(),
+ )],
+ parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() },
+ })
+ }
+
#[test]
fn test_generated_obsolete_extension() {
generate_bridge_reject_obsolete_headers_and_messages!(
@@ -546,7 +664,7 @@ mod tests {
let priority_boost = BridgeGrandpaWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_relay_header_call_ex(200),
+ &submit_relay_header_call(200),
)
.1
.unwrap()
@@ -564,7 +682,7 @@ mod tests {
let priority_boost = BridgeGrandpaWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_relay_header_call_ex(200),
+ &submit_relay_header_call(200),
)
.1
.unwrap()
@@ -601,7 +719,8 @@ mod tests {
type BridgeParachainsWrapper = CheckAndBoostBridgeParachainsTransactions<
TestRuntime,
- RefundableParachain<(), BridgedUnderlyingParachain>,
+ (),
+ BridgedUnderlyingParachain,
ConstU64<1_000>,
SlashDestination,
>;
@@ -613,7 +732,7 @@ mod tests {
let priority_boost = BridgeParachainsWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_parachain_head_call_ex(200),
+ &submit_parachain_head_call(200),
)
.1
.unwrap()
@@ -631,7 +750,7 @@ mod tests {
let priority_boost = BridgeParachainsWrapper::validate(
&relayer_account_at_this_chain(),
- &submit_parachain_head_call_ex(200),
+ &submit_parachain_head_call(200),
)
.1
.unwrap()
diff --git a/bridges/bin/runtime-common/src/integrity.rs b/bridges/bin/runtime-common/src/integrity.rs
index d3827a14dd6cc24e088a8d05d26aba9d769eb213..2ff6c4c9165aade8899bc4d8fea47da43f59ec8b 100644
--- a/bridges/bin/runtime-common/src/integrity.rs
+++ b/bridges/bin/runtime-common/src/integrity.rs
@@ -19,26 +19,33 @@
//! Most of the tests in this module assume that the bridge is using standard (see `crate::messages`
//! module for details) configuration.
-use crate::{messages, messages::MessageBridge};
-
-use bp_messages::{InboundLaneData, MessageNonce};
-use bp_runtime::{Chain, ChainId};
+use bp_header_chain::ChainWithGrandpa;
+use bp_messages::{ChainWithMessages, InboundLaneData, MessageNonce};
+use bp_runtime::Chain;
use codec::Encode;
use frame_support::{storage::generator::StorageValue, traits::Get, weights::Weight};
use frame_system::limits;
use pallet_bridge_messages::WeightInfoExt as _;
+// Re-export to avoid include all dependencies everywhere.
+#[doc(hidden)]
+pub mod __private {
+ pub use bp_xcm_bridge_hub;
+ pub use static_assertions;
+}
+
/// Macro that ensures that the runtime configuration and chain primitives crate are sharing
/// the same types (nonce, block number, hash, hasher, account id and header).
#[macro_export]
macro_rules! assert_chain_types(
( runtime: $r:path, this_chain: $this:path ) => {
{
+ use frame_system::{Config as SystemConfig, pallet_prelude::{BlockNumberFor, HeaderFor}};
+ use $crate::integrity::__private::static_assertions::assert_type_eq_all;
+
// if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
// configuration is used), or something has broke existing configuration (meaning that all bridged chains
// and relays will stop functioning)
- use frame_system::{Config as SystemConfig, pallet_prelude::{BlockNumberFor, HeaderFor}};
- use static_assertions::assert_type_eq_all;
assert_type_eq_all!(<$r as SystemConfig>::Nonce, bp_runtime::NonceOf<$this>);
assert_type_eq_all!(BlockNumberFor<$r>, bp_runtime::BlockNumberOf<$this>);
@@ -50,23 +57,6 @@ macro_rules! assert_chain_types(
}
);
-/// Macro that ensures that the bridge GRANDPA pallet is configured properly to bridge with given
-/// chain.
-#[macro_export]
-macro_rules! assert_bridge_grandpa_pallet_types(
- ( runtime: $r:path, with_bridged_chain_grandpa_instance: $i:path, bridged_chain: $bridged:path ) => {
- {
- // if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
- // configuration is used), or something has broke existing configuration (meaning that all bridged chains
- // and relays will stop functioning)
- use pallet_bridge_grandpa::Config as GrandpaConfig;
- use static_assertions::assert_type_eq_all;
-
- assert_type_eq_all!(<$r as GrandpaConfig<$i>>::BridgedChain, $bridged);
- }
- }
-);
-
/// Macro that ensures that the bridge messages pallet is configured properly to bridge using given
/// configuration.
#[macro_export]
@@ -74,32 +64,31 @@ macro_rules! assert_bridge_messages_pallet_types(
(
runtime: $r:path,
with_bridged_chain_messages_instance: $i:path,
- bridge: $bridge:path
+ this_chain: $this:path,
+ bridged_chain: $bridged:path,
) => {
{
+ use $crate::integrity::__private::bp_xcm_bridge_hub::XcmAsPlainPayload;
+ use $crate::integrity::__private::static_assertions::assert_type_eq_all;
+ use bp_messages::ChainWithMessages;
+ use bp_runtime::Chain;
+ use pallet_bridge_messages::Config as BridgeMessagesConfig;
+
// if one of asserts fail, then either bridge isn't configured properly (or alternatively - non-standard
// configuration is used), or something has broke existing configuration (meaning that all bridged chains
// and relays will stop functioning)
- use $crate::messages::{
- source::{FromThisChainMessagePayload, TargetHeaderChainAdapter},
- target::{FromBridgedChainMessagePayload, SourceHeaderChainAdapter},
- AccountIdOf, BalanceOf, BridgedChain, ThisChain,
- };
- use pallet_bridge_messages::Config as MessagesConfig;
- use static_assertions::assert_type_eq_all;
-
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::OutboundPayload, FromThisChainMessagePayload);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::InboundRelayer, AccountIdOf>);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::ThisChain, $this);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::BridgedChain, $bridged);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::TargetHeaderChain, TargetHeaderChainAdapter<$bridge>);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::SourceHeaderChain, SourceHeaderChainAdapter<$bridge>);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::OutboundPayload, XcmAsPlainPayload);
+ assert_type_eq_all!(<$r as BridgeMessagesConfig<$i>>::InboundPayload, XcmAsPlainPayload);
}
}
);
/// Macro that combines four other macro calls - `assert_chain_types`, `assert_bridge_types`,
-/// `assert_bridge_grandpa_pallet_types` and `assert_bridge_messages_pallet_types`. It may be used
+/// and `assert_bridge_messages_pallet_types`. It may be used
/// at the chain that is implementing complete standard messages bridge (i.e. with bridge GRANDPA
/// and messages pallets deployed).
#[macro_export]
@@ -108,20 +97,15 @@ macro_rules! assert_complete_bridge_types(
runtime: $r:path,
with_bridged_chain_grandpa_instance: $gi:path,
with_bridged_chain_messages_instance: $mi:path,
- bridge: $bridge:path,
this_chain: $this:path,
bridged_chain: $bridged:path,
) => {
$crate::assert_chain_types!(runtime: $r, this_chain: $this);
- $crate::assert_bridge_grandpa_pallet_types!(
- runtime: $r,
- with_bridged_chain_grandpa_instance: $gi,
- bridged_chain: $bridged
- );
$crate::assert_bridge_messages_pallet_types!(
runtime: $r,
with_bridged_chain_messages_instance: $mi,
- bridge: $bridge
+ this_chain: $this,
+ bridged_chain: $bridged,
);
}
);
@@ -184,50 +168,27 @@ where
);
}
-/// Parameters for asserting messages pallet constants.
-#[derive(Debug)]
-pub struct AssertBridgeMessagesPalletConstants {
- /// Maximal number of unrewarded relayer entries in a confirmation transaction at the bridged
- /// chain.
- pub max_unrewarded_relayers_in_bridged_confirmation_tx: MessageNonce,
- /// Maximal number of unconfirmed messages in a confirmation transaction at the bridged chain.
- pub max_unconfirmed_messages_in_bridged_confirmation_tx: MessageNonce,
- /// Identifier of the bridged chain.
- pub bridged_chain_id: ChainId,
-}
-
/// Test that the constants, used in messages pallet configuration are valid.
-pub fn assert_bridge_messages_pallet_constants(params: AssertBridgeMessagesPalletConstants)
+pub fn assert_bridge_messages_pallet_constants()
where
R: pallet_bridge_messages::Config,
MI: 'static,
{
assert!(
- !R::ActiveOutboundLanes::get().is_empty(),
- "ActiveOutboundLanes ({:?}) must not be empty",
- R::ActiveOutboundLanes::get(),
- );
- assert!(
- R::MaxUnrewardedRelayerEntriesAtInboundLane::get() <= params.max_unrewarded_relayers_in_bridged_confirmation_tx,
- "MaxUnrewardedRelayerEntriesAtInboundLane ({}) must be <= than the hardcoded value for bridged chain: {}",
- R::MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- params.max_unrewarded_relayers_in_bridged_confirmation_tx,
- );
- assert!(
- R::MaxUnconfirmedMessagesAtInboundLane::get() <= params.max_unconfirmed_messages_in_bridged_confirmation_tx,
- "MaxUnrewardedRelayerEntriesAtInboundLane ({}) must be <= than the hardcoded value for bridged chain: {}",
- R::MaxUnconfirmedMessagesAtInboundLane::get(),
- params.max_unconfirmed_messages_in_bridged_confirmation_tx,
+ pallet_bridge_messages::BridgedChainOf::::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX
+ <= pallet_bridge_messages::BridgedChainOf::::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
+ "MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX ({}) of {:?} is larger than \
+ its MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX ({}). This makes \
+ no sense",
+ pallet_bridge_messages::BridgedChainOf::::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
+ pallet_bridge_messages::BridgedChainOf::::ID,
+ pallet_bridge_messages::BridgedChainOf::::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
);
- assert_eq!(R::BridgedChainId::get(), params.bridged_chain_id);
}
/// Parameters for asserting bridge pallet names.
#[derive(Debug)]
pub struct AssertBridgePalletNames<'a> {
- /// Name of the messages pallet, deployed at the bridged chain and used to bridge with this
- /// chain.
- pub with_this_chain_messages_pallet_name: &'a str,
/// Name of the GRANDPA pallet, deployed at this chain and used to bridge with the bridged
/// chain.
pub with_bridged_chain_grandpa_pallet_name: &'a str,
@@ -238,18 +199,22 @@ pub struct AssertBridgePalletNames<'a> {
/// Tests that bridge pallet names used in `construct_runtime!()` macro call are matching constants
/// from chain primitives crates.
-pub fn assert_bridge_pallet_names(params: AssertBridgePalletNames)
+fn assert_bridge_pallet_names(params: AssertBridgePalletNames)
where
- B: MessageBridge,
R: pallet_bridge_grandpa::Config + pallet_bridge_messages::Config,
GI: 'static,
MI: 'static,
{
- assert_eq!(B::BRIDGED_MESSAGES_PALLET_NAME, params.with_this_chain_messages_pallet_name);
+ // check that the bridge GRANDPA pallet has required name
assert_eq!(
pallet_bridge_grandpa::PalletOwner::::storage_value_final_key().to_vec(),
- bp_runtime::storage_value_key(params.with_bridged_chain_grandpa_pallet_name, "PalletOwner",).0,
+ bp_runtime::storage_value_key(
+ params.with_bridged_chain_grandpa_pallet_name,
+ "PalletOwner",
+ ).0,
);
+
+ // check that the bridge messages pallet has required name
assert_eq!(
pallet_bridge_messages::PalletOwner::::storage_value_final_key().to_vec(),
bp_runtime::storage_value_key(
@@ -262,35 +227,58 @@ where
/// Parameters for asserting complete standard messages bridge.
#[derive(Debug)]
-pub struct AssertCompleteBridgeConstants<'a> {
+pub struct AssertCompleteBridgeConstants {
/// Parameters to assert this chain constants.
pub this_chain_constants: AssertChainConstants,
- /// Parameters to assert messages pallet constants.
- pub messages_pallet_constants: AssertBridgeMessagesPalletConstants,
- /// Parameters to assert pallet names constants.
- pub pallet_names: AssertBridgePalletNames<'a>,
}
-/// All bridge-related constants tests for the complete standard messages bridge (i.e. with bridge
-/// GRANDPA and messages pallets deployed).
-pub fn assert_complete_bridge_constants(params: AssertCompleteBridgeConstants)
-where
+/// All bridge-related constants tests for the complete standard relay-chain messages bridge
+/// (i.e. with bridge GRANDPA and messages pallets deployed).
+pub fn assert_complete_with_relay_chain_bridge_constants(
+ params: AssertCompleteBridgeConstants,
+) where
R: frame_system::Config
+ pallet_bridge_grandpa::Config
+ pallet_bridge_messages::Config,
GI: 'static,
MI: 'static,
- B: MessageBridge,
{
assert_chain_constants::(params.this_chain_constants);
assert_bridge_grandpa_pallet_constants::();
- assert_bridge_messages_pallet_constants::(params.messages_pallet_constants);
- assert_bridge_pallet_names::(params.pallet_names);
+ assert_bridge_messages_pallet_constants::();
+ assert_bridge_pallet_names::(AssertBridgePalletNames {
+ with_bridged_chain_grandpa_pallet_name:
+ >::BridgedChain::WITH_CHAIN_GRANDPA_PALLET_NAME,
+ with_bridged_chain_messages_pallet_name:
+ >::BridgedChain::WITH_CHAIN_MESSAGES_PALLET_NAME,
+ });
+}
+
+/// All bridge-related constants tests for the complete standard parachain messages bridge
+/// (i.e. with bridge GRANDPA, parachains and messages pallets deployed).
+pub fn assert_complete_with_parachain_bridge_constants(
+ params: AssertCompleteBridgeConstants,
+) where
+ R: frame_system::Config
+ + pallet_bridge_grandpa::Config
+ + pallet_bridge_messages::Config,
+ GI: 'static,
+ MI: 'static,
+ RelayChain: ChainWithGrandpa,
+{
+ assert_chain_constants::(params.this_chain_constants);
+ assert_bridge_grandpa_pallet_constants::();
+ assert_bridge_messages_pallet_constants::();
+ assert_bridge_pallet_names::(AssertBridgePalletNames {
+ with_bridged_chain_grandpa_pallet_name: RelayChain::WITH_CHAIN_GRANDPA_PALLET_NAME,
+ with_bridged_chain_messages_pallet_name:
+ >::BridgedChain::WITH_CHAIN_MESSAGES_PALLET_NAME,
+ });
}
/// Check that the message lane weights are correct.
pub fn check_message_lane_weights<
- C: Chain,
+ C: ChainWithMessages,
T: frame_system::Config + pallet_bridge_messages::Config,
MessagesPalletInstance: 'static,
>(
@@ -308,14 +296,20 @@ pub fn check_message_lane_weights<
// check basic weight assumptions
pallet_bridge_messages::ensure_weights_are_correct::>();
+ // check that the maximal message dispatch weight is below hardcoded limit
+ pallet_bridge_messages::ensure_maximal_message_dispatch::>(
+ C::maximal_incoming_message_size(),
+ C::maximal_incoming_message_dispatch_weight(),
+ );
+
// check that weights allow us to receive messages
- let max_incoming_message_proof_size = bridged_chain_extra_storage_proof_size
- .saturating_add(messages::target::maximal_incoming_message_size(C::max_extrinsic_size()));
+ let max_incoming_message_proof_size =
+ bridged_chain_extra_storage_proof_size.saturating_add(C::maximal_incoming_message_size());
pallet_bridge_messages::ensure_able_to_receive_message::>(
C::max_extrinsic_size(),
C::max_extrinsic_weight(),
max_incoming_message_proof_size,
- messages::target::maximal_incoming_message_dispatch_weight(C::max_extrinsic_weight()),
+ C::maximal_incoming_message_dispatch_weight(),
);
// check that weights allow us to receive delivery confirmations
diff --git a/bridges/bin/runtime-common/src/lib.rs b/bridges/bin/runtime-common/src/lib.rs
index 5679acd6006ccb8540f940f0f90363f902d643f7..ac8b013086b1bd63da2ed2e14d40002341be1758 100644
--- a/bridges/bin/runtime-common/src/lib.rs
+++ b/bridges/bin/runtime-common/src/lib.rs
@@ -20,17 +20,11 @@
#![cfg_attr(not(feature = "std"), no_std)]
pub mod extensions;
-pub mod messages;
pub mod messages_api;
pub mod messages_benchmarking;
-pub mod messages_call_ext;
-pub mod messages_generation;
-pub mod messages_xcm_extension;
pub mod parachains_benchmarking;
mod mock;
#[cfg(feature = "integrity-test")]
pub mod integrity;
-
-const LOG_TARGET_BRIDGE_DISPATCH: &str = "runtime::bridge-dispatch";
diff --git a/bridges/bin/runtime-common/src/messages.rs b/bridges/bin/runtime-common/src/messages.rs
deleted file mode 100644
index 03801d5279d0a8453542336d8089f5c887a3d005..0000000000000000000000000000000000000000
--- a/bridges/bin/runtime-common/src/messages.rs
+++ /dev/null
@@ -1,704 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common 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.
-
-// Parity Bridges Common 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 Parity Bridges Common. If not, see >;
-}
-
-/// This chain that has `pallet-bridge-messages` module.
-pub trait ThisChainWithMessages: UnderlyingChainProvider {
- /// Call origin on the chain.
- type RuntimeOrigin;
-}
-
-/// Bridged chain that has `pallet-bridge-messages` module.
-pub trait BridgedChainWithMessages: UnderlyingChainProvider {}
-
-/// This chain in context of message bridge.
-pub type ThisChain = ::ThisChain;
-/// Bridged chain in context of message bridge.
-pub type BridgedChain = ::BridgedChain;
-/// Hash used on the chain.
-pub type HashOf = bp_runtime::HashOf<::Chain>;
-/// Hasher used on the chain.
-pub type HasherOf = bp_runtime::HasherOf>;
-/// Account id used on the chain.
-pub type AccountIdOf = bp_runtime::AccountIdOf>;
-/// Type of balances that is used on the chain.
-pub type BalanceOf = bp_runtime::BalanceOf>;
-
-/// Sub-module that is declaring types required for processing This -> Bridged chain messages.
-pub mod source {
- use super::*;
-
- /// Message payload for This -> Bridged chain messages.
- pub type FromThisChainMessagePayload = crate::messages_xcm_extension::XcmAsPlainPayload;
-
- /// Maximal size of outbound message payload.
- pub struct FromThisChainMaximalOutboundPayloadSize(PhantomData);
-
- impl Get for FromThisChainMaximalOutboundPayloadSize {
- fn get() -> u32 {
- maximal_message_size::()
- }
- }
-
- /// Messages delivery proof from bridged chain:
- ///
- /// - hash of finalized header;
- /// - storage proof of inbound lane state;
- /// - lane id.
- #[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
- pub struct FromBridgedChainMessagesDeliveryProof {
- /// Hash of the bridge header the proof is for.
- pub bridged_header_hash: BridgedHeaderHash,
- /// Storage trie proof generated for [`Self::bridged_header_hash`].
- pub storage_proof: RawStorageProof,
- /// Lane id of which messages were delivered and the proof is for.
- pub lane: LaneId,
- }
-
- impl Size for FromBridgedChainMessagesDeliveryProof {
- fn size(&self) -> u32 {
- u32::try_from(
- self.storage_proof
- .iter()
- .fold(0usize, |sum, node| sum.saturating_add(node.len())),
- )
- .unwrap_or(u32::MAX)
- }
- }
-
- /// 'Parsed' message delivery proof - inbound lane id and its state.
- pub type ParsedMessagesDeliveryProofFromBridgedChain =
- (LaneId, InboundLaneData>>);
-
- /// Return maximal message size of This -> Bridged chain message.
- pub fn maximal_message_size() -> u32 {
- super::target::maximal_incoming_message_size(
- UnderlyingChainOf::>::max_extrinsic_size(),
- )
- }
-
- /// `TargetHeaderChain` implementation that is using default types and perform default checks.
- pub struct TargetHeaderChainAdapter(PhantomData);
-
- impl TargetHeaderChain>>
- for TargetHeaderChainAdapter
- {
- type MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof>>;
-
- fn verify_message(payload: &FromThisChainMessagePayload) -> Result<(), VerificationError> {
- verify_chain_message::(payload)
- }
-
- fn verify_messages_delivery_proof(
- proof: Self::MessagesDeliveryProof,
- ) -> Result<(LaneId, InboundLaneData>>), VerificationError> {
- verify_messages_delivery_proof::(proof)
- }
- }
-
- /// Do basic Bridged-chain specific verification of This -> Bridged chain message.
- ///
- /// Ok result from this function means that the delivery transaction with this message
- /// may be 'mined' by the target chain.
- pub fn verify_chain_message(
- payload: &FromThisChainMessagePayload,
- ) -> Result<(), VerificationError> {
- // IMPORTANT: any error that is returned here is fatal for the bridge, because
- // this code is executed at the bridge hub and message sender actually lives
- // at some sibling parachain. So we are failing **after** the message has been
- // sent and we can't report it back to sender (unless error report mechanism is
- // embedded into message and its dispatcher).
-
- // apart from maximal message size check (see below), we should also check the message
- // dispatch weight here. But we assume that the bridged chain will just push the message
- // to some queue (XCMP, UMP, DMP), so the weight is constant and fits the block.
-
- // The maximal size of extrinsic at Substrate-based chain depends on the
- // `frame_system::Config::MaximumBlockLength` and
- // `frame_system::Config::AvailableBlockRatio` constants. This check is here to be sure that
- // the lane won't stuck because message is too large to fit into delivery transaction.
- //
- // **IMPORTANT NOTE**: the delivery transaction contains storage proof of the message, not
- // the message itself. The proof is always larger than the message. But unless chain state
- // is enormously large, it should be several dozens/hundreds of bytes. The delivery
- // transaction also contains signatures and signed extensions. Because of this, we reserve
- // 1/3 of the the maximal extrinsic size for this data.
- if payload.len() > maximal_message_size::() as usize {
- return Err(VerificationError::MessageTooLarge)
- }
-
- Ok(())
- }
-
- /// Verify proof of This -> Bridged chain messages delivery.
- ///
- /// This function is used when Bridged chain is directly using GRANDPA finality. For Bridged
- /// parachains, please use the `verify_messages_delivery_proof_from_parachain`.
- pub fn verify_messages_delivery_proof(
- proof: FromBridgedChainMessagesDeliveryProof>>,
- ) -> Result, VerificationError> {
- let FromBridgedChainMessagesDeliveryProof { bridged_header_hash, storage_proof, lane } =
- proof;
- let mut storage =
- B::BridgedHeaderChain::storage_proof_checker(bridged_header_hash, storage_proof)
- .map_err(VerificationError::HeaderChain)?;
- // Messages delivery proof is just proof of single storage key read => any error
- // is fatal.
- let storage_inbound_lane_data_key = bp_messages::storage_keys::inbound_lane_data_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- &lane,
- );
- let inbound_lane_data = storage
- .read_and_decode_mandatory_value(storage_inbound_lane_data_key.0.as_ref())
- .map_err(VerificationError::InboundLaneStorage)?;
-
- // check that the storage proof doesn't have any untouched trie nodes
- storage.ensure_no_unused_nodes().map_err(VerificationError::StorageProof)?;
-
- Ok((lane, inbound_lane_data))
- }
-}
-
-/// Sub-module that is declaring types required for processing Bridged -> This chain messages.
-pub mod target {
- use super::*;
-
- /// Decoded Bridged -> This message payload.
- pub type FromBridgedChainMessagePayload = crate::messages_xcm_extension::XcmAsPlainPayload;
-
- /// Messages proof from bridged chain:
- ///
- /// - hash of finalized header;
- /// - storage proof of messages and (optionally) outbound lane state;
- /// - lane id;
- /// - nonces (inclusive range) of messages which are included in this proof.
- #[derive(Clone, Decode, Encode, Eq, PartialEq, RuntimeDebug, TypeInfo)]
- pub struct FromBridgedChainMessagesProof {
- /// Hash of the finalized bridged header the proof is for.
- pub bridged_header_hash: BridgedHeaderHash,
- /// A storage trie proof of messages being delivered.
- pub storage_proof: RawStorageProof,
- /// Messages in this proof are sent over this lane.
- pub lane: LaneId,
- /// Nonce of the first message being delivered.
- pub nonces_start: MessageNonce,
- /// Nonce of the last message being delivered.
- pub nonces_end: MessageNonce,
- }
-
- impl Size for FromBridgedChainMessagesProof {
- fn size(&self) -> u32 {
- u32::try_from(
- self.storage_proof
- .iter()
- .fold(0usize, |sum, node| sum.saturating_add(node.len())),
- )
- .unwrap_or(u32::MAX)
- }
- }
-
- /// Return maximal dispatch weight of the message we're able to receive.
- pub fn maximal_incoming_message_dispatch_weight(maximal_extrinsic_weight: Weight) -> Weight {
- maximal_extrinsic_weight / 2
- }
-
- /// Return maximal message size given maximal extrinsic size.
- pub fn maximal_incoming_message_size(maximal_extrinsic_size: u32) -> u32 {
- maximal_extrinsic_size / 3 * 2
- }
-
- /// `SourceHeaderChain` implementation that is using default types and perform default checks.
- pub struct SourceHeaderChainAdapter(PhantomData);
-
- impl SourceHeaderChain for SourceHeaderChainAdapter {
- type MessagesProof = FromBridgedChainMessagesProof>>;
-
- fn verify_messages_proof(
- proof: Self::MessagesProof,
- messages_count: u32,
- ) -> Result, VerificationError> {
- verify_messages_proof::(proof, messages_count)
- }
- }
-
- /// Verify proof of Bridged -> This chain messages.
- ///
- /// This function is used when Bridged chain is directly using GRANDPA finality. For Bridged
- /// parachains, please use the `verify_messages_proof_from_parachain`.
- ///
- /// The `messages_count` argument verification (sane limits) is supposed to be made
- /// outside of this function. This function only verifies that the proof declares exactly
- /// `messages_count` messages.
- pub fn verify_messages_proof(
- proof: FromBridgedChainMessagesProof>>,
- messages_count: u32,
- ) -> Result, VerificationError> {
- let FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane,
- nonces_start,
- nonces_end,
- } = proof;
- let storage =
- B::BridgedHeaderChain::storage_proof_checker(bridged_header_hash, storage_proof)
- .map_err(VerificationError::HeaderChain)?;
- let mut parser = StorageProofCheckerAdapter::<_, B> { storage, _dummy: Default::default() };
- let nonces_range = nonces_start..=nonces_end;
-
- // receiving proofs where end < begin is ok (if proof includes outbound lane state)
- let messages_in_the_proof = nonces_range.checked_len().unwrap_or(0);
- if messages_in_the_proof != MessageNonce::from(messages_count) {
- return Err(VerificationError::MessagesCountMismatch)
- }
-
- // Read messages first. All messages that are claimed to be in the proof must
- // be in the proof. So any error in `read_value`, or even missing value is fatal.
- //
- // Mind that we allow proofs with no messages if outbound lane state is proved.
- let mut messages = Vec::with_capacity(messages_in_the_proof as _);
- for nonce in nonces_range {
- let message_key = MessageKey { lane_id: lane, nonce };
- let message_payload = parser.read_and_decode_message_payload(&message_key)?;
- messages.push(Message { key: message_key, payload: message_payload });
- }
-
- // Now let's check if proof contains outbound lane state proof. It is optional, so
- // we simply ignore `read_value` errors and missing value.
- let proved_lane_messages = ProvedLaneMessages {
- lane_state: parser.read_and_decode_outbound_lane_data(&lane)?,
- messages,
- };
-
- // Now we may actually check if the proof is empty or not.
- if proved_lane_messages.lane_state.is_none() && proved_lane_messages.messages.is_empty() {
- return Err(VerificationError::EmptyMessageProof)
- }
-
- // check that the storage proof doesn't have any untouched trie nodes
- parser
- .storage
- .ensure_no_unused_nodes()
- .map_err(VerificationError::StorageProof)?;
-
- // We only support single lane messages in this generated_schema
- let mut proved_messages = ProvedMessages::new();
- proved_messages.insert(lane, proved_lane_messages);
-
- Ok(proved_messages)
- }
-
- struct StorageProofCheckerAdapter {
- storage: StorageProofChecker,
- _dummy: sp_std::marker::PhantomData,
- }
-
- impl StorageProofCheckerAdapter {
- fn read_and_decode_outbound_lane_data(
- &mut self,
- lane_id: &LaneId,
- ) -> Result, VerificationError> {
- let storage_outbound_lane_data_key = bp_messages::storage_keys::outbound_lane_data_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- lane_id,
- );
-
- self.storage
- .read_and_decode_opt_value(storage_outbound_lane_data_key.0.as_ref())
- .map_err(VerificationError::OutboundLaneStorage)
- }
-
- fn read_and_decode_message_payload(
- &mut self,
- message_key: &MessageKey,
- ) -> Result {
- let storage_message_key = bp_messages::storage_keys::message_key(
- B::BRIDGED_MESSAGES_PALLET_NAME,
- &message_key.lane_id,
- message_key.nonce,
- );
- self.storage
- .read_and_decode_mandatory_value(storage_message_key.0.as_ref())
- .map_err(VerificationError::MessageStorage)
- }
- }
-}
-
-/// The `BridgeMessagesCall` used by a chain.
-pub type BridgeMessagesCallOf = bp_messages::BridgeMessagesCall<
- bp_runtime::AccountIdOf,
- target::FromBridgedChainMessagesProof>,
- source::FromBridgedChainMessagesDeliveryProof>,
->;
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::{
- messages_generation::{
- encode_all_messages, encode_lane_data, prepare_messages_storage_proof,
- },
- mock::*,
- };
- use bp_header_chain::{HeaderChainError, StoredHeaderDataBuilder};
- use bp_runtime::{HeaderId, StorageProofError};
- use codec::Encode;
- use sp_core::H256;
- use sp_runtime::traits::Header as _;
- use sp_trie::accessed_nodes_tracker::Error as AccessedNodesTrackerError;
-
- #[test]
- fn verify_chain_message_rejects_message_with_too_large_declared_weight() {
- assert!(source::verify_chain_message::(&vec![
- 42;
- BRIDGED_CHAIN_MAX_EXTRINSIC_WEIGHT -
- 1
- ])
- .is_err());
- }
-
- #[test]
- fn verify_chain_message_rejects_message_too_large_message() {
- assert!(source::verify_chain_message::(&vec![
- 0;
- source::maximal_message_size::()
- as usize + 1
- ],)
- .is_err());
- }
-
- #[test]
- fn verify_chain_message_accepts_maximal_message() {
- assert_eq!(
- source::verify_chain_message::(&vec![
- 0;
- source::maximal_message_size::()
- as _
- ],),
- Ok(()),
- );
- }
-
- fn using_messages_proof(
- nonces_end: MessageNonce,
- outbound_lane_data: Option,
- encode_message: impl Fn(MessageNonce, &MessagePayload) -> Option>,
- encode_outbound_lane_data: impl Fn(&OutboundLaneData) -> Vec,
- test: impl Fn(target::FromBridgedChainMessagesProof) -> R,
- ) -> R {
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- TEST_LANE_ID,
- 1..=nonces_end,
- outbound_lane_data,
- bp_runtime::StorageProofSize::Minimal(0),
- vec![42],
- encode_message,
- encode_outbound_lane_data,
- );
-
- sp_io::TestExternalities::new(Default::default()).execute_with(move || {
- let bridged_header = BridgedChainHeader::new(
- 0,
- Default::default(),
- state_root,
- Default::default(),
- Default::default(),
- );
- let bridged_header_hash = bridged_header.hash();
-
- pallet_bridge_grandpa::BestFinalized::::put(HeaderId(
- 0,
- bridged_header_hash,
- ));
- pallet_bridge_grandpa::ImportedHeaders::::insert(
- bridged_header_hash,
- bridged_header.build(),
- );
- test(target::FromBridgedChainMessagesProof {
- bridged_header_hash,
- storage_proof,
- lane: TEST_LANE_ID,
- nonces_start: 1,
- nonces_end,
- })
- })
- }
-
- #[test]
- fn messages_proof_is_rejected_if_declared_less_than_actual_number_of_messages() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 5)
- }),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-
- #[test]
- fn messages_proof_is_rejected_if_declared_more_than_actual_number_of_messages() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 15)
- }),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_header_is_missing_from_the_chain() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- let bridged_header_hash =
- pallet_bridge_grandpa::BestFinalized::::get().unwrap().1;
- pallet_bridge_grandpa::ImportedHeaders::::remove(bridged_header_hash);
- target::verify_messages_proof::(proof, 10)
- }),
- Err(VerificationError::HeaderChain(HeaderChainError::UnknownHeader)),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_header_state_root_mismatches() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |proof| {
- let bridged_header_hash =
- pallet_bridge_grandpa::BestFinalized::::get().unwrap().1;
- pallet_bridge_grandpa::ImportedHeaders::::insert(
- bridged_header_hash,
- BridgedChainHeader::new(
- 0,
- Default::default(),
- Default::default(),
- Default::default(),
- Default::default(),
- )
- .build(),
- );
- target::verify_messages_proof::(proof, 10)
- }),
- Err(VerificationError::HeaderChain(HeaderChainError::StorageProof(
- StorageProofError::StorageRootMismatch
- ))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_has_duplicate_trie_nodes() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |mut proof| {
- let node = proof.storage_proof.pop().unwrap();
- proof.storage_proof.push(node.clone());
- proof.storage_proof.push(node);
- target::verify_messages_proof::(proof, 10)
- },),
- Err(VerificationError::HeaderChain(HeaderChainError::StorageProof(
- StorageProofError::StorageProof(sp_trie::StorageProofError::DuplicateNodes.into())
- ))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_has_unused_trie_nodes() {
- assert_eq!(
- using_messages_proof(10, None, encode_all_messages, encode_lane_data, |mut proof| {
- proof.storage_proof.push(vec![42]);
- target::verify_messages_proof::(proof, 10)
- },),
- Err(VerificationError::StorageProof(StorageProofError::AccessedNodesTracker(
- AccessedNodesTrackerError::UnusedNodes.into()
- ))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_required_message_is_missing() {
- matches!(
- using_messages_proof(
- 10,
- None,
- |n, m| if n != 5 { Some(m.encode()) } else { None },
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 10)
- ),
- Err(VerificationError::MessageStorage(StorageProofError::StorageValueEmpty)),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_message_decode_fails() {
- matches!(
- using_messages_proof(
- 10,
- None,
- |n, m| {
- let mut m = m.encode();
- if n == 5 {
- m = vec![42]
- }
- Some(m)
- },
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 10),
- ),
- Err(VerificationError::MessageStorage(StorageProofError::StorageValueDecodeFailed(_))),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_outbound_lane_state_decode_fails() {
- matches!(
- using_messages_proof(
- 10,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- |d| {
- let mut d = d.encode();
- d.truncate(1);
- d
- },
- |proof| target::verify_messages_proof::(proof, 10),
- ),
- Err(VerificationError::OutboundLaneStorage(
- StorageProofError::StorageValueDecodeFailed(_)
- )),
- );
- }
-
- #[test]
- fn message_proof_is_rejected_if_it_is_empty() {
- assert_eq!(
- using_messages_proof(0, None, encode_all_messages, encode_lane_data, |proof| {
- target::verify_messages_proof::(proof, 0)
- },),
- Err(VerificationError::EmptyMessageProof),
- );
- }
-
- #[test]
- fn non_empty_message_proof_without_messages_is_accepted() {
- assert_eq!(
- using_messages_proof(
- 0,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 0),
- ),
- Ok(vec![(
- TEST_LANE_ID,
- ProvedLaneMessages {
- lane_state: Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- messages: Vec::new(),
- },
- )]
- .into_iter()
- .collect()),
- );
- }
-
- #[test]
- fn non_empty_message_proof_is_accepted() {
- assert_eq!(
- using_messages_proof(
- 1,
- Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- encode_all_messages,
- encode_lane_data,
- |proof| target::verify_messages_proof::(proof, 1),
- ),
- Ok(vec![(
- TEST_LANE_ID,
- ProvedLaneMessages {
- lane_state: Some(OutboundLaneData {
- oldest_unpruned_nonce: 1,
- latest_received_nonce: 1,
- latest_generated_nonce: 1,
- }),
- messages: vec![Message {
- key: MessageKey { lane_id: TEST_LANE_ID, nonce: 1 },
- payload: vec![42],
- }],
- },
- )]
- .into_iter()
- .collect()),
- );
- }
-
- #[test]
- fn verify_messages_proof_does_not_panic_if_messages_count_mismatches() {
- assert_eq!(
- using_messages_proof(1, None, encode_all_messages, encode_lane_data, |mut proof| {
- proof.nonces_end = u64::MAX;
- target::verify_messages_proof::(proof, u32::MAX)
- },),
- Err(VerificationError::MessagesCountMismatch),
- );
- }
-}
diff --git a/bridges/bin/runtime-common/src/messages_benchmarking.rs b/bridges/bin/runtime-common/src/messages_benchmarking.rs
index 74494f7908045fac601b4c3f64a456ad12dacd6f..1880e65547fe6d5e0af71e6ec7c6e0e214f20866 100644
--- a/bridges/bin/runtime-common/src/messages_benchmarking.rs
+++ b/bridges/bin/runtime-common/src/messages_benchmarking.rs
@@ -19,23 +19,22 @@
#![cfg(feature = "runtime-benchmarks")]
-use crate::{
- messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
- AccountIdOf, BridgedChain, HashOf, MessageBridge, ThisChain,
- },
+use bp_messages::{
+ source_chain::FromBridgedChainMessagesDeliveryProof,
+ target_chain::FromBridgedChainMessagesProof, MessagePayload,
+};
+use bp_polkadot_core::parachains::ParaHash;
+use bp_runtime::{AccountIdOf, Chain, HashOf, Parachain};
+use codec::Encode;
+use frame_support::weights::Weight;
+use pallet_bridge_messages::{
+ benchmarking::{MessageDeliveryProofParams, MessageProofParams},
messages_generation::{
encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof,
prepare_messages_storage_proof,
},
+ BridgedChainOf, ThisChainOf,
};
-
-use bp_messages::MessagePayload;
-use bp_polkadot_core::parachains::ParaHash;
-use bp_runtime::{Chain, Parachain, StorageProofSize, UnderlyingChainOf};
-use codec::Encode;
-use frame_support::weights::Weight;
-use pallet_bridge_messages::benchmarking::{MessageDeliveryProofParams, MessageProofParams};
use sp_runtime::traits::{Header, Zero};
use sp_std::prelude::*;
use xcm::latest::prelude::*;
@@ -45,11 +44,7 @@ fn prepare_inbound_message(
params: &MessageProofParams,
successful_dispatch_message_generator: impl Fn(usize) -> MessagePayload,
) -> MessagePayload {
- // we only care about **this** message size when message proof needs to be `Minimal`
- let expected_size = match params.size {
- StorageProofSize::Minimal(size) => size as usize,
- _ => 0,
- };
+ let expected_size = params.proof_params.db_size.unwrap_or(0) as usize;
// if we don't need a correct message, then we may just return some random blob
if !params.is_successful_dispatch_expected {
@@ -75,25 +70,32 @@ fn prepare_inbound_message(
/// This method is intended to be used when benchmarking pallet, linked to the chain that
/// uses GRANDPA finality. For parachains, please use the `prepare_message_proof_from_parachain`
/// function.
-pub fn prepare_message_proof_from_grandpa_chain(
+pub fn prepare_message_proof_from_grandpa_chain(
params: MessageProofParams,
message_generator: impl Fn(usize) -> MessagePayload,
-) -> (FromBridgedChainMessagesProof>>, Weight)
+) -> (FromBridgedChainMessagesProof>>, Weight)
where
- R: pallet_bridge_grandpa::Config>>,
+ R: pallet_bridge_grandpa::Config>
+ + pallet_bridge_messages::Config<
+ MI,
+ BridgedHeaderChain = pallet_bridge_grandpa::Pallet,
+ >,
FI: 'static,
- B: MessageBridge,
+ MI: 'static,
{
// prepare storage proof
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- params.lane,
- params.message_nonces.clone(),
- params.outbound_lane_data.clone(),
- params.size,
- prepare_inbound_message(¶ms, message_generator),
- encode_all_messages,
- encode_lane_data,
- );
+ let (state_root, storage_proof) =
+ prepare_messages_storage_proof::, ThisChainOf>(
+ params.lane,
+ params.message_nonces.clone(),
+ params.outbound_lane_data.clone(),
+ params.proof_params,
+ |_| prepare_inbound_message(¶ms, &message_generator),
+ encode_all_messages,
+ encode_lane_data,
+ false,
+ false,
+ );
// update runtime storage
let (_, bridged_header_hash) = insert_header_to_grandpa_pallet::(state_root);
@@ -118,30 +120,33 @@ where
/// This method is intended to be used when benchmarking pallet, linked to the chain that
/// uses parachain finality. For GRANDPA chains, please use the
/// `prepare_message_proof_from_grandpa_chain` function.
-pub fn prepare_message_proof_from_parachain(
+pub fn prepare_message_proof_from_parachain(
params: MessageProofParams,
message_generator: impl Fn(usize) -> MessagePayload,
-) -> (FromBridgedChainMessagesProof>>, Weight)
+) -> (FromBridgedChainMessagesProof>>, Weight)
where
- R: pallet_bridge_parachains::Config,
+ R: pallet_bridge_parachains::Config + pallet_bridge_messages::Config,
PI: 'static,
- B: MessageBridge,
- UnderlyingChainOf>: Chain + Parachain,
+ MI: 'static,
+ BridgedChainOf: Chain + Parachain,
{
// prepare storage proof
- let (state_root, storage_proof) = prepare_messages_storage_proof::(
- params.lane,
- params.message_nonces.clone(),
- params.outbound_lane_data.clone(),
- params.size,
- prepare_inbound_message(¶ms, message_generator),
- encode_all_messages,
- encode_lane_data,
- );
+ let (state_root, storage_proof) =
+ prepare_messages_storage_proof::, ThisChainOf>(
+ params.lane,
+ params.message_nonces.clone(),
+ params.outbound_lane_data.clone(),
+ params.proof_params,
+ |_| prepare_inbound_message(¶ms, &message_generator),
+ encode_all_messages,
+ encode_lane_data,
+ false,
+ false,
+ );
// update runtime storage
let (_, bridged_header_hash) =
- insert_header_to_parachains_pallet::>>(state_root);
+ insert_header_to_parachains_pallet::>(state_root);
(
FromBridgedChainMessagesProof {
@@ -160,21 +165,24 @@ where
/// This method is intended to be used when benchmarking pallet, linked to the chain that
/// uses GRANDPA finality. For parachains, please use the
/// `prepare_message_delivery_proof_from_parachain` function.
-pub fn prepare_message_delivery_proof_from_grandpa_chain(
- params: MessageDeliveryProofParams>>,
-) -> FromBridgedChainMessagesDeliveryProof>>
+pub fn prepare_message_delivery_proof_from_grandpa_chain(
+ params: MessageDeliveryProofParams>>,
+) -> FromBridgedChainMessagesDeliveryProof>>
where
- R: pallet_bridge_grandpa::Config>>,
+ R: pallet_bridge_grandpa::Config>
+ + pallet_bridge_messages::Config<
+ MI,
+ BridgedHeaderChain = pallet_bridge_grandpa::Pallet,
+ >,
FI: 'static,
- B: MessageBridge,
+ MI: 'static,
{
// prepare storage proof
let lane = params.lane;
- let (state_root, storage_proof) = prepare_message_delivery_storage_proof::(
- params.lane,
- params.inbound_lane_data,
- params.size,
- );
+ let (state_root, storage_proof) = prepare_message_delivery_storage_proof::<
+ BridgedChainOf,
+ ThisChainOf,
+ >(params.lane, params.inbound_lane_data, params.proof_params);
// update runtime storage
let (_, bridged_header_hash) = insert_header_to_grandpa_pallet::(state_root);
@@ -191,26 +199,25 @@ where
/// This method is intended to be used when benchmarking pallet, linked to the chain that
/// uses parachain finality. For GRANDPA chains, please use the
/// `prepare_message_delivery_proof_from_grandpa_chain` function.
-pub fn prepare_message_delivery_proof_from_parachain(
- params: MessageDeliveryProofParams>>,
-) -> FromBridgedChainMessagesDeliveryProof>>
+pub fn prepare_message_delivery_proof_from_parachain(
+ params: MessageDeliveryProofParams>>,
+) -> FromBridgedChainMessagesDeliveryProof>>
where
- R: pallet_bridge_parachains::Config,
+ R: pallet_bridge_parachains::Config + pallet_bridge_messages::Config,
PI: 'static,
- B: MessageBridge,
- UnderlyingChainOf>: Chain + Parachain,
+ MI: 'static,
+ BridgedChainOf: Chain + Parachain,
{
// prepare storage proof
let lane = params.lane;
- let (state_root, storage_proof) = prepare_message_delivery_storage_proof::(
- params.lane,
- params.inbound_lane_data,
- params.size,
- );
+ let (state_root, storage_proof) = prepare_message_delivery_storage_proof::<
+ BridgedChainOf,
+ ThisChainOf,
+ >(params.lane, params.inbound_lane_data, params.proof_params);
// update runtime storage
let (_, bridged_header_hash) =
- insert_header_to_parachains_pallet::>>(state_root);
+ insert_header_to_parachains_pallet::>(state_root);
FromBridgedChainMessagesDeliveryProof {
bridged_header_hash: bridged_header_hash.into(),
diff --git a/bridges/bin/runtime-common/src/messages_xcm_extension.rs b/bridges/bin/runtime-common/src/messages_xcm_extension.rs
deleted file mode 100644
index 46ed4da0d85481fcc7223740084945924f9c710f..0000000000000000000000000000000000000000
--- a/bridges/bin/runtime-common/src/messages_xcm_extension.rs
+++ /dev/null
@@ -1,502 +0,0 @@
-// Copyright (C) Parity Technologies (UK) Ltd.
-// This file is part of Parity Bridges Common.
-
-// Parity Bridges Common 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.
-
-// Parity Bridges Common 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 Parity Bridges Common. If not, see ),
-}
-
-/// [`XcmBlobMessageDispatch`] is responsible for dispatching received messages
-///
-/// It needs to be used at the target bridge hub.
-pub struct XcmBlobMessageDispatch {
- _marker: sp_std::marker::PhantomData<(DispatchBlob, Weights, Channel)>,
-}
-
-impl<
- BlobDispatcher: DispatchBlob,
- Weights: MessagesPalletWeights,
- Channel: XcmChannelStatusProvider,
- > MessageDispatch for XcmBlobMessageDispatch
-{
- type DispatchPayload = XcmAsPlainPayload;
- type DispatchLevelResult = XcmBlobMessageDispatchResult;
-
- fn is_active() -> bool {
- !Channel::is_congested()
- }
-
- fn dispatch_weight(message: &mut DispatchMessage) -> Weight {
- match message.data.payload {
- Ok(ref payload) => {
- let payload_size = payload.encoded_size().saturated_into();
- Weights::message_dispatch_weight(payload_size)
- },
- Err(_) => Weight::zero(),
- }
- }
-
- fn dispatch(
- message: DispatchMessage,
- ) -> MessageDispatchResult {
- let payload = match message.data.payload {
- Ok(payload) => payload,
- Err(e) => {
- log::error!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] payload error: {:?} - message_nonce: {:?}",
- e,
- message.key.nonce
- );
- return MessageDispatchResult {
- unspent_weight: Weight::zero(),
- dispatch_level_result: XcmBlobMessageDispatchResult::InvalidPayload,
- }
- },
- };
- let dispatch_level_result = match BlobDispatcher::dispatch_blob(payload) {
- Ok(_) => {
- log::debug!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] DispatchBlob::dispatch_blob was ok - message_nonce: {:?}",
- message.key.nonce
- );
- XcmBlobMessageDispatchResult::Dispatched
- },
- Err(e) => {
- log::error!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "[XcmBlobMessageDispatch] DispatchBlob::dispatch_blob failed, error: {:?} - message_nonce: {:?}",
- e, message.key.nonce
- );
- XcmBlobMessageDispatchResult::NotDispatched(Some(e))
- },
- };
- MessageDispatchResult { unspent_weight: Weight::zero(), dispatch_level_result }
- }
-}
-
-/// A pair of sending chain location and message lane, used by this chain to send messages
-/// over the bridge.
-#[cfg_attr(feature = "std", derive(Debug, Eq, PartialEq))]
-pub struct SenderAndLane {
- /// Sending chain relative location.
- pub location: Location,
- /// Message lane, used by the sending chain.
- pub lane: LaneId,
-}
-
-impl SenderAndLane {
- /// Create new object using provided location and lane.
- pub fn new(location: Location, lane: LaneId) -> Self {
- SenderAndLane { location, lane }
- }
-}
-
-/// [`XcmBlobHauler`] is responsible for sending messages to the bridge "point-to-point link" from
-/// one side, where on the other it can be dispatched by [`XcmBlobMessageDispatch`].
-pub trait XcmBlobHauler {
- /// Runtime that has messages pallet deployed.
- type Runtime: MessagesConfig;
- /// Instance of the messages pallet that is used to send messages.
- type MessagesInstance: 'static;
-
- /// Actual XCM message sender (`HRMP` or `UMP`) to the source chain
- /// location (`Self::SenderAndLane::get().location`).
- type ToSourceChainSender: SendXcm;
- /// An XCM message that is sent to the sending chain when the bridge queue becomes congested.
- type CongestedMessage: Get>>;
- /// An XCM message that is sent to the sending chain when the bridge queue becomes not
- /// congested.
- type UncongestedMessage: Get>>;
-
- /// Returns `true` if we want to handle congestion.
- fn supports_congestion_detection() -> bool {
- Self::CongestedMessage::get().is_some() || Self::UncongestedMessage::get().is_some()
- }
-}
-
-/// XCM bridge adapter which connects [`XcmBlobHauler`] with [`pallet_bridge_messages`] and
-/// makes sure that XCM blob is sent to the outbound lane to be relayed.
-///
-/// It needs to be used at the source bridge hub.
-pub struct XcmBlobHaulerAdapter(
- sp_std::marker::PhantomData<(XcmBlobHauler, Lanes)>,
-);
-
-impl<
- H: XcmBlobHauler,
- Lanes: Get>,
- > OnMessagesDelivered for XcmBlobHaulerAdapter
-{
- fn on_messages_delivered(lane: LaneId, enqueued_messages: MessageNonce) {
- if let Some(sender_and_lane) =
- Lanes::get().iter().find(|link| link.0.lane == lane).map(|link| &link.0)
- {
- // notify XCM queue manager about updated lane state
- LocalXcmQueueManager::::on_bridge_messages_delivered(
- sender_and_lane,
- enqueued_messages,
- );
- }
- }
-}
-
-/// Manager of local XCM queues (and indirectly - underlying transport channels) that
-/// controls the queue state.
-///
-/// It needs to be used at the source bridge hub.
-pub struct LocalXcmQueueManager(PhantomData);
-
-/// Maximal number of messages in the outbound bridge queue. Once we reach this limit, we
-/// send a "congestion" XCM message to the sending chain.
-const OUTBOUND_LANE_CONGESTED_THRESHOLD: MessageNonce = 8_192;
-
-/// After we have sent "congestion" XCM message to the sending chain, we wait until number
-/// of messages in the outbound bridge queue drops to this count, before sending `uncongestion`
-/// XCM message.
-const OUTBOUND_LANE_UNCONGESTED_THRESHOLD: MessageNonce = 1_024;
-
-impl LocalXcmQueueManager {
- /// Must be called whenever we push a message to the bridge lane.
- pub fn on_bridge_message_enqueued(
- sender_and_lane: &SenderAndLane,
- enqueued_messages: MessageNonce,
- ) {
- // skip if we dont want to handle congestion
- if !H::supports_congestion_detection() {
- return
- }
-
- // if we have already sent the congestion signal, we don't want to do anything
- if Self::is_congested_signal_sent(sender_and_lane.lane) {
- return
- }
-
- // if the bridge queue is not congested, we don't want to do anything
- let is_congested = enqueued_messages > OUTBOUND_LANE_CONGESTED_THRESHOLD;
- if !is_congested {
- return
- }
-
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Sending 'congested' XCM message to {:?} to avoid overloading lane {:?}: there are\
- {} messages queued at the bridge queue",
- sender_and_lane.location,
- sender_and_lane.lane,
- enqueued_messages,
- );
-
- if let Err(e) = Self::send_congested_signal(sender_and_lane) {
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Failed to send the 'congested' XCM message to {:?}: {:?}",
- sender_and_lane.location,
- e,
- );
- }
- }
-
- /// Must be called whenever we receive a message delivery confirmation.
- pub fn on_bridge_messages_delivered(
- sender_and_lane: &SenderAndLane,
- enqueued_messages: MessageNonce,
- ) {
- // skip if we don't want to handle congestion
- if !H::supports_congestion_detection() {
- return
- }
-
- // if we have not sent the congestion signal before, we don't want to do anything
- if !Self::is_congested_signal_sent(sender_and_lane.lane) {
- return
- }
-
- // if the bridge queue is still congested, we don't want to do anything
- let is_congested = enqueued_messages > OUTBOUND_LANE_UNCONGESTED_THRESHOLD;
- if is_congested {
- return
- }
-
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Sending 'uncongested' XCM message to {:?}. Lane {:?}: there are\
- {} messages queued at the bridge queue",
- sender_and_lane.location,
- sender_and_lane.lane,
- enqueued_messages,
- );
-
- if let Err(e) = Self::send_uncongested_signal(sender_and_lane) {
- log::info!(
- target: crate::LOG_TARGET_BRIDGE_DISPATCH,
- "Failed to send the 'uncongested' XCM message to {:?}: {:?}",
- sender_and_lane.location,
- e,
- );
- }
- }
-
- /// Returns true if we have sent "congested" signal to the `sending_chain_location`.
- fn is_congested_signal_sent(lane: LaneId) -> bool {
- OutboundLanesCongestedSignals::::get(lane)
- }
-
- /// Send congested signal to the `sending_chain_location`.
- fn send_congested_signal(sender_and_lane: &SenderAndLane) -> Result<(), SendError> {
- if let Some(msg) = H::CongestedMessage::get() {
- send_xcm::(sender_and_lane.location.clone(), msg)?;
- OutboundLanesCongestedSignals::::insert(
- sender_and_lane.lane,
- true,
- );
- }
- Ok(())
- }
-
- /// Send `uncongested` signal to the `sending_chain_location`.
- fn send_uncongested_signal(sender_and_lane: &SenderAndLane) -> Result<(), SendError> {
- if let Some(msg) = H::UncongestedMessage::get() {
- send_xcm::(sender_and_lane.location.clone(), msg)?;
- OutboundLanesCongestedSignals::::remove(
- sender_and_lane.lane,
- );
- }
- Ok(())
- }
-}
-
-/// Adapter for the implementation of `GetVersion`, which attempts to find the minimal
-/// configured XCM version between the destination `dest` and the bridge hub location provided as
-/// `Get`.
-pub struct XcmVersionOfDestAndRemoteBridge(
- sp_std::marker::PhantomData<(Version, RemoteBridge)>,
-);
-impl> GetVersion
- for XcmVersionOfDestAndRemoteBridge 
+
+# {name}
+
+This crate is part of the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk/).
+
+