diff --git a/.config/lychee.toml b/.config/lychee.toml
index 1de9fcd559dd9ea14fb603b7740efebcb893ed93..b7bb6f0ce4953bcdba91685d8161d9046765cdcb 100644
--- a/.config/lychee.toml
+++ b/.config/lychee.toml
@@ -32,7 +32,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 +40,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/taplo.toml b/.config/taplo.toml
index 2c6ccfb2b34440686764c39ed6db1c73ed940f06..7cbc1b075125ad237f16d5d7dd33b0de7089ac38 100644
--- a/.config/taplo.toml
+++ b/.config/taplo.toml
@@ -33,3 +33,10 @@ keys = ["build"]
[rule.formatting]
reorder_arrays = false
+
+[[rule]]
+include = ["Cargo.toml"]
+keys = ["workspace.dependencies"]
+
+[rule.formatting]
+reorder_keys = true
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/.forklift/config-gitlab.toml b/.forklift/config-gitlab.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ab3b2729a46d4e54dc77df1175d4ebe79eda46d0
--- /dev/null
+++ b/.forklift/config-gitlab.toml
@@ -0,0 +1,33 @@
+[compression]
+type = "zstd"
+
+[compression.zstd]
+compressionLevel = 3
+
+[general]
+jobNameVariable = "CI_JOB_NAME"
+jobsBlackList = []
+logLevel = "warn"
+threadsCount = 6
+
+[cache]
+extraEnv = ["RUNTIME_METADATA_HASH"]
+
+[metrics]
+enabled = true
+pushEndpoint = "placeholder"
+
+[metrics.extraLabels]
+environment = "production"
+job_name = "$CI_JOB_NAME"
+project_name = "$CI_PROJECT_PATH"
+
+[storage]
+type = "s3"
+
+[storage.s3]
+accessKeyId = "placeholder"
+bucketName = "placeholder"
+concurrency = 10
+endpointUrl = "placeholder"
+secretAccessKey = "placeholder"
diff --git a/.forklift/config.toml b/.forklift/config.toml
index ab3b2729a46d4e54dc77df1175d4ebe79eda46d0..6f8eed8882ea36f39d1f0a519180f92eb905f7be 100644
--- a/.forklift/config.toml
+++ b/.forklift/config.toml
@@ -23,11 +23,7 @@ job_name = "$CI_JOB_NAME"
project_name = "$CI_PROJECT_PATH"
[storage]
-type = "s3"
+type = "gcs"
-[storage.s3]
-accessKeyId = "placeholder"
-bucketName = "placeholder"
-concurrency = 10
-endpointUrl = "placeholder"
-secretAccessKey = "placeholder"
+[storage.gcs]
+bucketName = "parity-ci-forklift"
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/actions/set-up-gh/action.yml b/.github/actions/set-up-gh/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..fc16ce0b26334283b83266e381c1811738be87c9
--- /dev/null
+++ b/.github/actions/set-up-gh/action.yml
@@ -0,0 +1,36 @@
+name: 'install gh'
+description: 'Install the gh cli in a debian based distro and switches to the PR branch.'
+inputs:
+ pr-number:
+ description: "Number of the PR"
+ required: true
+ GH_TOKEN:
+ description: "GitHub token"
+ required: true
+outputs:
+ branch:
+ description: 'Branch name for the PR'
+ value: ${{ steps.branch.outputs.branch }}
+runs:
+ using: "composite"
+ steps:
+ - name: Instal gh cli
+ shell: bash
+ # Here it would get the script from previous step
+ run: |
+ (type -p wget >/dev/null || (apt update && apt-get install wget -y))
+ mkdir -p -m 755 /etc/apt/keyrings
+ wget -qO- https://cli.github.com/packages/githubcli-archive-keyring.gpg | tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null
+ chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg
+ echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+ apt update
+ apt install gh -y
+ git config --global --add safe.directory '*'
+ - run: gh pr checkout ${{ inputs.pr-number }}
+ shell: bash
+ env:
+ GITHUB_TOKEN: ${{ inputs.GH_TOKEN }}
+ - name: Export branch name
+ shell: bash
+ run: echo "branch=$(git rev-parse --abbrev-ref HEAD)" >> "$GITHUB_OUTPUT"
+ id: branch
diff --git a/.github/actions/set-up-mac/README.md b/.github/actions/set-up-mac/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..0bbc7112bd1d40e24c91d426df014a877166e3b0
--- /dev/null
+++ b/.github/actions/set-up-mac/README.md
@@ -0,0 +1,15 @@
+# How to use
+
+```yml
+ set-image:
+ runs-on: macos-latest
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ - id: set_image
+ run: cat .github/env >> $GITHUB_OUTPUT
+ - name: Install dependencies
+ uses: ./.github/actions/set-up-mac
+ with:
+ IMAGE: ${{ steps.set-image.outputs.IMAGE }}
+```
diff --git a/.github/actions/set-up-mac/action.yml b/.github/actions/set-up-mac/action.yml
new file mode 100644
index 0000000000000000000000000000000000000000..a3b026679402c2dc3b086cf572041b1f4bcc61e6
--- /dev/null
+++ b/.github/actions/set-up-mac/action.yml
@@ -0,0 +1,43 @@
+name: "Set up rust on mac"
+description: "Install the required tools for Mac runners"
+inputs:
+ IMAGE:
+ description: "Rust docker image"
+ required: true
+runs:
+ using: "composite"
+ steps:
+ - name: Install with Hombrew
+ shell: bash
+ run: brew install protobuf rustup openssl pkg-config zlib xz zstd llvm jq curl gcc make cmake
+ - name: Set version
+ shell: bash
+ run: |
+ VERSION=$(echo $IMAGE | sed -E 's/.*:bullseye-([^-]+)-.*/\1/')
+ echo $VERSION
+ echo "VERSION=$VERSION" >> $GITHUB_ENV
+ NIGHTLY=$(echo $IMAGE | sed -E 's/.*([0-9]{4}-[0-9]{2}-[0-9]{2}).*/\1/')
+ echo $NIGHTLY
+ echo "NIGHTLY=$NIGHTLY" >> $GITHUB_ENV
+ env:
+ IMAGE: ${{ inputs.IMAGE }}
+
+ - name: Install rustup
+ shell: bash
+ run: |
+ rustup-init -y
+ rustup install $VERSION
+ rustup default $VERSION
+ rustup toolchain install "nightly-${NIGHTLY}"
+
+ - name: MacOS Deps
+ shell: bash
+ run: |
+ rustup target add wasm32-unknown-unknown --toolchain $VERSION
+ rustup component add rust-src rustfmt clippy --toolchain $VERSION
+
+ - name: Check Rust
+ shell: bash
+ run: |
+ rustup show
+ rustup +nightly show
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 ed719cefec8bc97c921e11a1751889433f0991ea..adbc480c6ba1a69e8cdd112af4be378849d26315 100644
--- a/.github/review-bot.yml
+++ b/.github/review-bot.yml
@@ -9,6 +9,7 @@ rules:
- ^\.gitlab/.*
- ^\.config/nextest.toml
- ^\.cargo/.*
+ - ^\.forklift/.*
exclude:
- ^\.gitlab/pipeline/zombienet.*
type: "or"
@@ -33,6 +34,7 @@ rules:
- ^docker/.*
- ^\.github/.*
- ^\.gitlab/.*
+ - ^\.forklift/.*
- ^\.config/nextest.toml
- ^\.cargo/.*
minApprovals: 2
diff --git a/.github/scripts/check-workspace.py b/.github/scripts/check-workspace.py
index 1f8f103e4e157a8c1c804a618652741193ca5a00..d5197100ad253ed18b9a4df255faa88598883f91 100644
--- a/.github/scripts/check-workspace.py
+++ b/.github/scripts/check-workspace.py
@@ -135,8 +135,12 @@ def check_links(all_crates):
if dep_name in all_crates:
links.append((name, dep_name))
- if not 'path' in deps[dep]:
- broken.append((name, dep_name, "crate must be linked via `path`"))
+ if name == 'polkadot-sdk':
+ if not 'path' in deps[dep]:
+ broken.append((name, dep_name, "crate must use path"))
+ return
+ elif not 'workspace' in deps[dep] or not deps[dep]['workspace']:
+ broken.append((name, dep_name, "crate must use workspace inheritance"))
return
def check_crate(deps):
@@ -154,8 +158,6 @@ def check_links(all_crates):
check_crate(manifest)
-
-
links.sort()
broken.sort()
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..63bd6a2795aacfb019d582a06c37957ce565fd8b
--- /dev/null
+++ b/.github/scripts/cmd/cmd.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import json
+import argparse
+import _help
+
+_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)
+
+
+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}: {pallets}')
+ runtime_pallets_map[runtime['name']] = pallets
+
+ # filter out only the specified pallets from collected runtimes/pallets
+ if args.pallet:
+ print(f'Pallet: {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}')
+
+ 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)
+
+ header_path = os.path.abspath('./substrate/HEADER-APACHE2')
+
+ for runtime in runtime_pallets_map:
+ for pallet in runtime_pallets_map[runtime]:
+ config = runtimesMatrix[runtime]
+ 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")
+ else:
+ default_path = f"./{config['path']}/src/weights"
+ xcm_path = f"./{config['path']}/src/weights/xcm"
+ output_path = default_path if not pallet.startswith("pallet_xcm_benchmarks") else xcm_path
+ print(f'-- benchmarking {pallet} in {runtime} into {output_path}')
+ cmd = f"frame-omni-bencher v1 benchmark pallet --extrinsic=* --runtime=target/{profile}/wbuild/{config['package']}/{config['package'].replace('-', '_')}.wasm --pallet={pallet} --header={header_path} --output={output_path} --wasm-execution=compiled --steps=50 --repeat=20 --heap-pages=4096 --no-storage-info --no-min-squares --no-median-slopes"
+ print(f'-- Running: {cmd}')
+ 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)
+
+print('๐ Done')
diff --git a/.github/scripts/common/lib.sh b/.github/scripts/common/lib.sh
index f844e962c41def7625fa3d45ae3cbf81ecb57147..bfb3120ad9bba1d647ef8719d99ae885cee2dfb7 100755
--- a/.github/scripts/common/lib.sh
+++ b/.github/scripts/common/lib.sh
@@ -315,6 +315,7 @@ function import_gpg_keys() {
) &
done
wait
+ gpg -k $SEC
}
# 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/deny-git-deps.py b/.github/scripts/deny-git-deps.py
index 4b831c9347f75bdc3c74c80d3af652c37e7ae459..622fc64c488123a153b438af8516f3fa65133776 100644
--- a/.github/scripts/deny-git-deps.py
+++ b/.github/scripts/deny-git-deps.py
@@ -19,6 +19,7 @@ KNOWN_BAD_GIT_DEPS = {
root = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
workspace = Workspace.from_path(root)
+errors = []
def check_dep(dep, used_by):
if dep.location != DependencyLocation.GIT:
@@ -27,14 +28,23 @@ def check_dep(dep, used_by):
if used_by in KNOWN_BAD_GIT_DEPS.get(dep.name, []):
print(f'๐คจ Ignoring git dependency {dep.name} in {used_by}')
else:
- print(f'๐ซ Found git dependency {dep.name} in {used_by}')
- sys.exit(1)
+ errors.append(f'๐ซ Found git dependency {dep.name} in {used_by}')
# Check the workspace dependencies that can be inherited:
for dep in workspace.dependencies:
check_dep(dep, "workspace")
+ if workspace.crates.find_by_name(dep.name):
+ if dep.location != DependencyLocation.PATH:
+ errors.append(f'๐ซ Workspace must use path to link local dependency {dep.name}')
+
# And the dependencies of each crate:
for crate in workspace.crates:
for dep in crate.dependencies:
check_dep(dep, crate.name)
+
+if errors:
+ print('โ Found errors:')
+ for error in errors:
+ print(error)
+ sys.exit(1)
diff --git a/.github/scripts/generate-prdoc.py b/.github/scripts/generate-prdoc.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba7def20fcb99bb48830a0a75d789a1ca8c20397
--- /dev/null
+++ b/.github/scripts/generate-prdoc.py
@@ -0,0 +1,113 @@
+#!/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 = { "doc": [{}], "crates": [] }
+
+ prdoc["title"] = title
+ prdoc["doc"][0]["audience"] = audience
+ prdoc["doc"][0]["description"] = description
+
+ workspace = Workspace.from_path(".")
+
+ modified_paths = []
+ for diff in whatthepatch.parse_patch(patch):
+ modified_paths.append(diff.header.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")):
+ 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)
+ print(f"PrDoc for PR {pr} written to {path}")
+
+def parse_args():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--pr", type=int, required=True)
+ parser.add_argument("--audience", type=str, default="TODO")
+ parser.add_argument("--bump", type=str, default="TODO")
+ parser.add_argument("--force", type=str)
+ return parser.parse_args()
+
+if __name__ == "__main__":
+ args = parse_args()
+ force = True if args.force.lower() == "true" else False
+ print(f"Args: {args}, force: {force}")
+ from_pr_number(args.pr, args.audience, args.bump, force)
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
@@ -21,25 +68,21 @@ jobs:
- name: Rust compilation prerequisites
run: |
- rustup default nightly-2024-03-01
- rustup target add wasm32-unknown-unknown --toolchain nightly-2024-03-01
- rustup component add rust-src --toolchain nightly-2024-03-01
+ rustup default $TOOLCHAIN
+ rustup component add rust-src --toolchain $TOOLCHAIN
- name: install parity-publish
- run: cargo install parity-publish@0.5.1
-
- - 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
+ # Set the target dir to cache the build.
+ run: CARGO_TARGET_DIR=./target/ cargo install parity-publish@0.8.0 -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 --toolchain nightly-2024-03-01 -v; then
+
+ if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc $PRDOC_EXTRA_ARGS -v --toolchain $TOOLCHAIN; then
+
cat <> $GITHUB_OUTPUT
fmt:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
needs: [set-image]
container:
image: ${{ needs.set-image.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 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@692973e3d937129bcbf40652eb9f2f61becf3332 # 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
+ timeout-minutes: 20
needs: [set-image]
container:
image: ${{ needs.set-image.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
+ - name: fetch deps
+ run: |
+ # Pull all dependencies eagerly:
+ time cargo metadata --format-version=1 --locked > /dev/null
- name: run zepter
- run: zepter run check
+ run: |
+ zepter --version
+ time zepter run check
test-rust-features:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
needs: [set-image]
container:
image: ${{ needs.set-image.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
- name: run rust features
run: bash .gitlab/rust-features.sh .
check-toml-format:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
needs: [set-image]
container:
image: ${{ needs.set-image.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 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@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.0 (22. Sep 2023)
- name: install python deps
run: |
sudo apt-get update && sudo apt-get install -y python3-pip python3
@@ -94,16 +100,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@692973e3d937129bcbf40652eb9f2f61becf3332 # 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"
@@ -121,12 +129,12 @@ jobs:
markdownlint --config "$CONFIG" --ignore target .
check-umbrella:
runs-on: ubuntu-latest
- timeout-minutes: 10
+ timeout-minutes: 20
needs: [set-image]
container:
image: ${{ needs.set-image.outputs.IMAGE }}
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.0 (22. Sep 2023)
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.0 (22. Sep 2023)
- name: install python deps
run: pip3 install "cargo-workspace>=1.2.4" toml
- name: check umbrella correctness
@@ -148,3 +156,28 @@ 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
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ad9d0d1a959d6911fcafeb51b55f08a8dc200fc8
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,109 @@
+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:
+ # temporary disabled because currently doesn't work in merge queue
+ # changes:
+ # permissions:
+ # pull-requests: read
+ # uses: ./.github/workflows/reusable-check-changed-files.yml
+ set-image:
+ # GitHub Actions allows using 'env' in a container context.
+ # However, env variables don't work for forks: https://github.com/orgs/community/discussions/44322
+ # This workaround sets the container image for each job using 'set-image' job output.
+ runs-on: ubuntu-latest
+ outputs:
+ IMAGE: ${{ steps.set_image.outputs.IMAGE }}
+ RUNNER: ${{ steps.set_runner.outputs.RUNNER }}
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ - id: set_image
+ run: cat .github/env >> $GITHUB_OUTPUT
+ # By default we use spot machines that can be terminated at any time.
+ # Merge queues use persistent runners to avoid kicking off from queue when the runner is terminated.
+ - id: set_runner
+ run: |
+ # Run merge queues on persistent runners
+ if [[ $GITHUB_REF_NAME == *"gh-readonly-queue"* ]]; then
+ echo "RUNNER=arc-runners-polkadot-sdk-beefy-persistent" >> $GITHUB_OUTPUT
+ else
+ echo "RUNNER=arc-runners-polkadot-sdk-beefy" >> $GITHUB_OUTPUT
+ fi
+ cargo-clippy:
+ runs-on: ${{ needs.set-image.outputs.RUNNER }}
+ needs: [set-image]
+ # if: ${{ needs.changes.outputs.rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.set-image.outputs.IMAGE }}
+ env:
+ RUSTFLAGS: "-D warnings"
+ SKIP_WASM_BUILD: 1
+ steps:
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 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.set-image.outputs.RUNNER }}
+ needs: [set-image]
+ # if: ${{ needs.changes.outputs.rust }}
+ timeout-minutes: 40
+ container:
+ image: ${{ needs.set-image.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 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.set-image.outputs.RUNNER }}
+ needs: [set-image]
+ # if: ${{ needs.changes.outputs.rust }}
+ timeout-minutes: 30
+ container:
+ image: ${{ needs.set-image.outputs.IMAGE }}
+ steps:
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # 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]
+ steps:
+ - run: echo '### Good job! All the checks passed ๐' >> $GITHUB_STEP_SUMMARY
diff --git a/.github/workflows/cmd.yml b/.github/workflows/cmd.yml
new file mode 100644
index 0000000000000000000000000000000000000000..7a742751005d9c8ce324c1220366403764b6082b
--- /dev/null
+++ b/.github/workflows/cmd.yml
@@ -0,0 +1,452 @@
+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 .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..72da40f198394a0d651976721338bbc256d5855e
--- /dev/null
+++ b/.github/workflows/command-backport.yml
@@ -0,0 +1,66 @@
+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
+
+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: Create backport pull requests
+ uses: korthout/backport-action@v3
+ id: backport
+ with:
+ target_branches: stable2407
+ merge_commits: skip
+ github_token: ${{ secrets.GITHUB_TOKEN }}
+ pull_description: |
+ Backport #${pull_number} into `${target_branch}` (cc @${pull_author}).
+
+
+ pull_title: |
+ [${target_branch}] Backport #${pull_number}
+ experimental: >
+ {
+ "conflict_resolution": "draft_commit_conflicts"
+ }
+
+ - 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}`);
+ }
diff --git a/.github/workflows/command-inform.yml b/.github/workflows/command-inform.yml
new file mode 100644
index 0000000000000000000000000000000000000000..97346395319362b0455bcbcfbb490fa23e6b3b07
--- /dev/null
+++ b/.github/workflows/command-inform.yml
@@ -0,0 +1,22 @@
+name: Inform of new command action
+
+on:
+ issue_comment:
+ 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
+ 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/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..523c2b19ba892a760cb553fa9b33fccb6597bc68
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,141 @@
+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:
+ set-image:
+ # GitHub Actions allows using 'env' in a container context.
+ # However, env variables don't work for forks: https://github.com/orgs/community/discussions/44322
+ # This workaround sets the container image for each job using 'set-image' job output.
+ # TODO: remove once migration is complete or this workflow is fully stable
+ if: contains(github.event.label.name, 'GHA-migration') || contains(github.event.pull_request.labels.*.name, 'GHA-migration')
+ 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
+ test-rustdoc:
+ runs-on: arc-runners-polkadot-sdk-beefy
+ needs: [set-image]
+ container:
+ image: ${{ needs.set-image.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: [set-image]
+ container:
+ image: ${{ needs.set-image.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: [set-image, test-rustdoc]
+ container:
+ image: ${{ needs.set-image.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@c5a7806660adbe173f04e3e038b0ccdcd758773c # 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@c5a7806660adbe173f04e3e038b0ccdcd758773c # 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 9b5b89e34475699ccbcaeca34cd290882ee45a9a..9f96b92e0ce73eb1874ff7e11c9e43d820eaa649 100644
--- a/.github/workflows/publish-check-crates.yml
+++ b/.github/workflows/publish-check-crates.yml
@@ -12,7 +12,7 @@ jobs:
check-publish:
runs-on: ubuntu-latest
steps:
- - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+ - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7
- name: Rust Cache
uses: Swatinem/rust-cache@23bce251a8cd2ffc3c1075eaa2367cf899916d84 # v2.7.3
@@ -20,7 +20,7 @@ jobs:
cache-on-failure: true
- name: install parity-publish
- run: cargo install parity-publish@0.5.1
+ run: cargo install parity-publish@0.8.0
- 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 9643361d9d318f84d64a212358a825a8e0b5aa20..bee709a12076ed4a5ff212796f7691650f32ad7f 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@692973e3d937129bcbf40652eb9f2f61becf3332 # 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.5.1
+ run: cargo install parity-publish@0.8.0
- name: parity-publish claim
env:
diff --git a/.github/workflows/publish-subsystem-benchmarks.yml b/.github/workflows/publish-subsystem-benchmarks.yml
index 1a726b669e9094e8be53ef5a1ddb1b3198210d33..e5b9db0836f3f6a944778a30df49ea7f98b3af34 100644
--- a/.github/workflows/publish-subsystem-benchmarks.yml
+++ b/.github/workflows/publish-subsystem-benchmarks.yml
@@ -23,7 +23,7 @@ jobs:
echo "${{ github.event.inputs.output-file-path }}" | grep -P '^[a-z\-]+\.json'
- name: Checkout Sources
- uses: actions/checkout@v4.1.2
+ uses: actions/checkout@v4
with:
fetch-depth: 0
ref: "gh-pages"
diff --git a/.github/workflows/release-10_rc-automation.yml b/.github/workflows/release-10_rc-automation.yml
index 7231a8b75886d04ce18bb89fcef99029e3ab14c6..2d91850b82c180e25bbf87dfef529f8ab4667edd 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@692973e3d937129bcbf40652eb9f2f61becf3332 # 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",
@@ -144,6 +150,7 @@ members = [
"cumulus/test/service",
"cumulus/xcm/xcm-emulator",
"docs/sdk",
+ "docs/sdk/src/reference_docs/chain_spec_runtime",
"polkadot",
"polkadot/cli",
"polkadot/core-primitives",
@@ -225,7 +232,7 @@ members = [
"polkadot/xcm/xcm-builder",
"polkadot/xcm/xcm-executor",
"polkadot/xcm/xcm-executor/integration-tests",
- "polkadot/xcm/xcm-fee-payment-runtime-api",
+ "polkadot/xcm/xcm-runtime-apis",
"polkadot/xcm/xcm-simulator",
"polkadot/xcm/xcm-simulator/example",
"polkadot/xcm/xcm-simulator/fuzzer",
@@ -305,6 +312,7 @@ members = [
"substrate/frame/asset-conversion/ops",
"substrate/frame/asset-rate",
"substrate/frame/assets",
+ "substrate/frame/assets-freezer",
"substrate/frame/atomic-swap",
"substrate/frame/aura",
"substrate/frame/authority-discovery",
@@ -387,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",
@@ -515,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",
@@ -529,72 +541,851 @@ members = [
]
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]
-polkavm = "0.9.3"
-polkavm-linker = "0.9.2"
+Inflector = { version = "0.11.4" }
+aes-gcm = { version = "0.10" }
+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" }
+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 }
+ark-bls12-377-ext = { version = "0.4.1", default-features = false }
+ark-bls12-381 = { version = "0.4.0", default-features = false }
+ark-bls12-381-ext = { version = "0.4.1", default-features = false }
+ark-bw6-761 = { version = "0.4.0", default-features = false }
+ark-bw6-761-ext = { version = "0.4.1", default-features = false }
+ark-ec = { version = "0.4.2", default-features = false }
+ark-ed-on-bls12-377 = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-377-ext = { version = "0.4.1", default-features = false }
+ark-ed-on-bls12-381-bandersnatch = { version = "0.4.0", default-features = false }
+ark-ed-on-bls12-381-bandersnatch-ext = { version = "0.4.1", default-features = false }
+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.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 }
+asset-hub-westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend" }
+asset-hub-westend-runtime = { path = "cumulus/parachains/runtimes/assets/asset-hub-westend" }
+asset-test-utils = { path = "cumulus/parachains/runtimes/assets/test-utils", default-features = false }
+assets-common = { path = "cumulus/parachains/runtimes/assets/common", default-features = false }
+async-channel = { version = "1.8.0" }
+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.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.2", default-features = false }
+blake3 = { version = "1.5" }
+bounded-collections = { version = "0.2.0", default-features = false }
+bounded-vec = { version = "0.7" }
+bp-asset-hub-rococo = { path = "bridges/chains/chain-asset-hub-rococo", default-features = false }
+bp-asset-hub-westend = { path = "bridges/chains/chain-asset-hub-westend", default-features = false }
+bp-beefy = { path = "bridges/primitives/beefy", default-features = false }
+bp-bridge-hub-cumulus = { path = "bridges/chains/chain-bridge-hub-cumulus", default-features = false }
+bp-bridge-hub-kusama = { default-features = false, path = "bridges/chains/chain-bridge-hub-kusama" }
+bp-bridge-hub-polkadot = { path = "bridges/chains/chain-bridge-hub-polkadot", default-features = false }
+bp-bridge-hub-rococo = { path = "bridges/chains/chain-bridge-hub-rococo", default-features = false }
+bp-bridge-hub-westend = { path = "bridges/chains/chain-bridge-hub-westend", default-features = false }
+bp-header-chain = { path = "bridges/primitives/header-chain", default-features = false }
+bp-kusama = { default-features = false, path = "bridges/chains/chain-kusama" }
+bp-messages = { path = "bridges/primitives/messages", default-features = false }
+bp-parachains = { path = "bridges/primitives/parachains", default-features = false }
+bp-polkadot = { default-features = false, path = "bridges/chains/chain-polkadot" }
+bp-polkadot-bulletin = { path = "bridges/chains/chain-polkadot-bulletin", default-features = false }
+bp-polkadot-core = { path = "bridges/primitives/polkadot-core", default-features = false }
+bp-relayers = { path = "bridges/primitives/relayers", default-features = false }
+bp-rococo = { path = "bridges/chains/chain-rococo", default-features = false }
+bp-runtime = { path = "bridges/primitives/runtime", default-features = false }
+bp-test-utils = { path = "bridges/primitives/test-utils", default-features = false }
+bp-westend = { path = "bridges/chains/chain-westend", default-features = false }
+bp-xcm-bridge-hub = { path = "bridges/primitives/xcm-bridge-hub", default-features = false }
+bp-xcm-bridge-hub-router = { path = "bridges/primitives/xcm-bridge-hub-router", default-features = false }
+bridge-hub-common = { path = "cumulus/parachains/runtimes/bridge-hubs/common", default-features = false }
+bridge-hub-rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo" }
+bridge-hub-rococo-runtime = { path = "cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo", default-features = false }
+bridge-hub-test-utils = { path = "cumulus/parachains/runtimes/bridge-hubs/test-utils", default-features = false }
+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.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 }
+bytes = { version = "1.4.0", default-features = false }
+cargo_metadata = { version = "0.15.4" }
+cfg-expr = { version = "0.15.5" }
+cfg-if = { version = "1.0" }
+chain-spec-builder = { path = "substrate/bin/utils/chain-spec-builder", default-features = false, package = "staging-chain-spec-builder" }
+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.10" }
+clap-num = { version = "1.0.2" }
+clap_complete = { version = "4.0.2" }
+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-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 }
+cumulus-client-cli = { path = "cumulus/client/cli", default-features = false }
+cumulus-client-collator = { path = "cumulus/client/collator", default-features = false }
+cumulus-client-consensus-aura = { path = "cumulus/client/consensus/aura", default-features = false }
+cumulus-client-consensus-common = { path = "cumulus/client/consensus/common", default-features = false }
+cumulus-client-consensus-proposer = { path = "cumulus/client/consensus/proposer", default-features = false }
+cumulus-client-consensus-relay-chain = { path = "cumulus/client/consensus/relay-chain", default-features = false }
+cumulus-client-network = { path = "cumulus/client/network", default-features = false }
+cumulus-client-parachain-inherent = { path = "cumulus/client/parachain-inherent", default-features = false }
+cumulus-client-pov-recovery = { path = "cumulus/client/pov-recovery", default-features = false }
+cumulus-client-service = { path = "cumulus/client/service", default-features = false }
+cumulus-pallet-aura-ext = { path = "cumulus/pallets/aura-ext", default-features = false }
+cumulus-pallet-dmp-queue = { default-features = false, path = "cumulus/pallets/dmp-queue" }
+cumulus-pallet-parachain-system = { path = "cumulus/pallets/parachain-system", default-features = false }
+cumulus-pallet-parachain-system-proc-macro = { path = "cumulus/pallets/parachain-system/proc-macro", default-features = false }
+cumulus-pallet-session-benchmarking = { path = "cumulus/pallets/session-benchmarking", default-features = false }
+cumulus-pallet-solo-to-para = { path = "cumulus/pallets/solo-to-para", default-features = false }
+cumulus-pallet-xcm = { path = "cumulus/pallets/xcm", default-features = false }
+cumulus-pallet-xcmp-queue = { path = "cumulus/pallets/xcmp-queue", default-features = false }
+cumulus-ping = { path = "cumulus/parachains/pallets/ping", default-features = false }
+cumulus-primitives-aura = { path = "cumulus/primitives/aura", default-features = false }
+cumulus-primitives-core = { path = "cumulus/primitives/core", default-features = false }
+cumulus-primitives-parachain-inherent = { path = "cumulus/primitives/parachain-inherent", default-features = false }
+cumulus-primitives-proof-size-hostfunction = { path = "cumulus/primitives/proof-size-hostfunction", default-features = false }
+cumulus-primitives-storage-weight-reclaim = { path = "cumulus/primitives/storage-weight-reclaim", default-features = false }
+cumulus-primitives-timestamp = { path = "cumulus/primitives/timestamp", default-features = false }
+cumulus-primitives-utility = { path = "cumulus/primitives/utility", default-features = false }
+cumulus-relay-chain-inprocess-interface = { path = "cumulus/client/relay-chain-inprocess-interface", default-features = false }
+cumulus-relay-chain-interface = { path = "cumulus/client/relay-chain-interface", default-features = false }
+cumulus-relay-chain-minimal-node = { path = "cumulus/client/relay-chain-minimal-node", default-features = false }
+cumulus-relay-chain-rpc-interface = { path = "cumulus/client/relay-chain-rpc-interface", default-features = false }
+cumulus-test-client = { path = "cumulus/test/client" }
+cumulus-test-relay-sproof-builder = { path = "cumulus/test/relay-sproof-builder", default-features = false }
+cumulus-test-runtime = { path = "cumulus/test/runtime" }
+cumulus-test-service = { path = "cumulus/test/service" }
+curve25519-dalek = { version = "4.1.3" }
+derivative = { version = "2.2.0", default-features = false }
+derive-syn-parse = { version = "0.2.0" }
+derive_more = { version = "0.99.17", default-features = false }
+digest = { version = "0.10.3", default-features = false }
+directories = { version = "5.0.1" }
+dlmalloc = { version = "0.2.4" }
+docify = { version = "0.2.8" }
+dyn-clonable = { version = "0.9.0" }
+dyn-clone = { version = "1.0.16" }
+ed25519-dalek = { version = "2.1", default-features = false }
+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.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" }
+ethbloom = { version = "0.13.0", default-features = false }
+ethereum-types = { version = "0.14.1", default-features = false }
+exit-future = { version = "0.2.0" }
+expander = { version = "2.0.0" }
+fatality = { version = "0.1.1" }
+fdlimit = { version = "0.3.0" }
+femme = { version = "2.2.1" }
+filetime = { version = "0.2.16" }
+finality-grandpa = { version = "0.16.2", default-features = false }
+finality-relay = { path = "bridges/relays/finality" }
+flate2 = { version = "1.0" }
+fnv = { version = "1.0.6" }
+fork-tree = { path = "substrate/utils/fork-tree", default-features = false }
+forwarded-header-value = { version = "0.1.1" }
+fraction = { version = "0.13.1" }
+frame = { path = "substrate/frame", default-features = false, package = "polkadot-sdk-frame" }
+frame-benchmarking = { path = "substrate/frame/benchmarking", default-features = false }
+frame-benchmarking-cli = { path = "substrate/utils/frame/benchmarking-cli", default-features = false }
+frame-benchmarking-pallet-pov = { default-features = false, path = "substrate/frame/benchmarking/pov" }
+frame-election-provider-solution-type = { path = "substrate/frame/election-provider-support/solution-type", default-features = false }
+frame-election-provider-support = { path = "substrate/frame/election-provider-support", default-features = false }
+frame-executive = { path = "substrate/frame/executive", default-features = false }
+frame-metadata = { version = "16.0.0", default-features = false }
+frame-metadata-hash-extension = { path = "substrate/frame/metadata-hash-extension", default-features = false }
+frame-support = { path = "substrate/frame/support", default-features = false }
+frame-support-procedural = { path = "substrate/frame/support/procedural", default-features = false }
+frame-support-procedural-tools = { path = "substrate/frame/support/procedural/tools", default-features = false }
+frame-support-procedural-tools-derive = { path = "substrate/frame/support/procedural/tools/derive", default-features = false }
+frame-support-test = { path = "substrate/frame/support/test" }
+frame-system = { path = "substrate/frame/system", default-features = false }
+frame-system-benchmarking = { path = "substrate/frame/system/benchmarking", default-features = false }
+frame-system-rpc-runtime-api = { path = "substrate/frame/system/rpc/runtime-api", default-features = false }
+frame-try-runtime = { path = "substrate/frame/try-runtime", default-features = false }
+fs4 = { version = "0.7.0" }
+fs_extra = { version = "1.3.0" }
+futures = { version = "0.3.30" }
+futures-channel = { version = "0.3.23" }
+futures-timer = { version = "3.0.2" }
+futures-util = { version = "0.3.30", default-features = false }
+generate-bags = { path = "substrate/utils/frame/generate-bags", default-features = false }
+gethostname = { version = "0.2.3" }
+glob = { version = "0.3" }
+glutton-westend-runtime = { path = "cumulus/parachains/runtimes/glutton/glutton-westend" }
+governor = { version = "0.6.0" }
+gum = { path = "polkadot/node/gum", default-features = false, package = "tracing-gum" }
+gum-proc-macro = { path = "polkadot/node/gum/proc-macro", default-features = false, package = "tracing-gum-proc-macro" }
+handlebars = { version = "5.1.0" }
+hash-db = { version = "0.16.0", default-features = false }
+hash256-std-hasher = { version = "0.15.2", default-features = false }
+hex = { version = "0.4.3", default-features = false }
+hex-literal = { version = "0.4.1", default-features = false }
+hkdf = { version = "0.12.0" }
+hmac = { version = "0.12.1" }
+honggfuzz = { version = "0.5.55" }
+http = { version = "1.1" }
+http-body = { version = "1", default-features = false }
+http-body-util = { version = "0.1.2", default-features = false }
+hyper = { version = "1.3.1", default-features = false }
+hyper-rustls = { version = "0.24.2" }
+hyper-util = { version = "0.1.5", default-features = false }
+# TODO: remove hyper v0.14 https://github.com/paritytech/polkadot-sdk/issues/4896
+hyperv14 = { package = "hyper", version = "0.14.29", default-features = false }
+impl-serde = { version = "0.4.0", default-features = false }
+impl-trait-for-tuples = { version = "0.2.2" }
+indexmap = { version = "2.0.0" }
+indicatif = { version = "0.17.7" }
+integer-sqrt = { version = "0.1.2" }
+ip_network = { version = "0.4.1" }
+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.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" }
+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.155" }
+libfuzzer-sys = { version = "0.4" }
+libp2p = { version = "0.52.4" }
+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.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 }
+merkleized-metadata = { version = "0.1.0" }
+merlin = { version = "3.0", default-features = false }
+messages-relay = { path = "bridges/relays/messages" }
+metered = { version = "0.6.1", default-features = false, package = "prioritized-metered-channel" }
+mick-jaeger = { version = "0.1.8" }
+milagro-bls = { version = "1.5.4", default-features = false, package = "snowbridge-milagro-bls" }
+minimal-template-node = { path = "templates/minimal/node" }
+minimal-template-runtime = { path = "templates/minimal/runtime" }
+mixnet = { version = "0.7.0" }
+mmr-gadget = { path = "substrate/client/merkle-mountain-range", default-features = false }
+mmr-lib = { version = "0.5.2", package = "ckb-merkle-mountain-range" }
+mmr-rpc = { path = "substrate/client/merkle-mountain-range/rpc", default-features = false }
+mockall = { version = "0.11.3" }
+multiaddr = { version = "0.18.1" }
+multihash = { version = "0.19.1", default-features = false }
+multihash-codetable = { version = "0.1.1" }
+multistream-select = { version = "0.13.0" }
+names = { version = "0.14.0", default-features = false }
+nix = { version = "0.28.0" }
+node-cli = { path = "substrate/bin/node/cli", package = "staging-node-cli" }
+node-inspect = { path = "substrate/bin/node/inspect", default-features = false, package = "staging-node-inspect" }
+node-primitives = { path = "substrate/bin/node/primitives", default-features = false }
+node-rpc = { path = "substrate/bin/node/rpc" }
+node-testing = { path = "substrate/bin/node/testing" }
+nohash-hasher = { version = "0.2.0" }
+novelpoly = { version = "2.0.0", package = "reed-solomon-novelpoly" }
+num-bigint = { version = "0.4.3" }
+num-format = { version = "0.4.3" }
+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.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 }
+pallet-asset-conversion-tx-payment = { path = "substrate/frame/transaction-payment/asset-conversion-tx-payment", default-features = false }
+pallet-asset-rate = { path = "substrate/frame/asset-rate", default-features = false }
+pallet-asset-tx-payment = { path = "substrate/frame/transaction-payment/asset-tx-payment", default-features = false }
+pallet-assets = { path = "substrate/frame/assets", default-features = false }
+pallet-assets-freezer = { path = "substrate/frame/assets-freezer", default-features = false }
+pallet-atomic-swap = { default-features = false, path = "substrate/frame/atomic-swap" }
+pallet-aura = { path = "substrate/frame/aura", default-features = false }
+pallet-authority-discovery = { path = "substrate/frame/authority-discovery", default-features = false }
+pallet-authorship = { path = "substrate/frame/authorship", default-features = false }
+pallet-babe = { path = "substrate/frame/babe", default-features = false }
+pallet-bags-list = { path = "substrate/frame/bags-list", default-features = false }
+pallet-bags-list-remote-tests = { path = "substrate/frame/bags-list/remote-tests" }
+pallet-balances = { path = "substrate/frame/balances", default-features = false }
+pallet-beefy = { path = "substrate/frame/beefy", default-features = false }
+pallet-beefy-mmr = { path = "substrate/frame/beefy-mmr", default-features = false }
+pallet-bounties = { path = "substrate/frame/bounties", default-features = false }
+pallet-bridge-grandpa = { path = "bridges/modules/grandpa", default-features = false }
+pallet-bridge-messages = { path = "bridges/modules/messages", default-features = false }
+pallet-bridge-parachains = { path = "bridges/modules/parachains", default-features = false }
+pallet-bridge-relayers = { path = "bridges/modules/relayers", default-features = false }
+pallet-broker = { path = "substrate/frame/broker", default-features = false }
+pallet-child-bounties = { path = "substrate/frame/child-bounties", default-features = false }
+pallet-collator-selection = { path = "cumulus/pallets/collator-selection", default-features = false }
+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", 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 }
+pallet-conviction-voting = { path = "substrate/frame/conviction-voting", default-features = false }
+pallet-core-fellowship = { path = "substrate/frame/core-fellowship", default-features = false }
+pallet-default-config-example = { path = "substrate/frame/examples/default-config", default-features = false }
+pallet-delegated-staking = { path = "substrate/frame/delegated-staking", default-features = false }
+pallet-democracy = { path = "substrate/frame/democracy", default-features = false }
+pallet-dev-mode = { path = "substrate/frame/examples/dev-mode", default-features = false }
+pallet-election-provider-multi-phase = { path = "substrate/frame/election-provider-multi-phase", default-features = false }
+pallet-election-provider-support-benchmarking = { path = "substrate/frame/election-provider-support/benchmarking", default-features = false }
+pallet-elections-phragmen = { path = "substrate/frame/elections-phragmen", default-features = false }
+pallet-example-basic = { path = "substrate/frame/examples/basic", default-features = false }
+pallet-example-frame-crate = { path = "substrate/frame/examples/frame-crate", default-features = false }
+pallet-example-kitchensink = { path = "substrate/frame/examples/kitchensink", default-features = false }
+pallet-example-mbm = { path = "substrate/frame/examples/multi-block-migrations", default-features = false }
+pallet-example-offchain-worker = { path = "substrate/frame/examples/offchain-worker", default-features = false }
+pallet-example-single-block-migrations = { path = "substrate/frame/examples/single-block-migrations", default-features = false }
+pallet-example-split = { path = "substrate/frame/examples/split", default-features = false }
+pallet-example-tasks = { path = "substrate/frame/examples/tasks", default-features = false }
+pallet-examples = { path = "substrate/frame/examples" }
+pallet-fast-unstake = { path = "substrate/frame/fast-unstake", default-features = false }
+pallet-glutton = { path = "substrate/frame/glutton", default-features = false }
+pallet-grandpa = { path = "substrate/frame/grandpa", default-features = false }
+pallet-identity = { path = "substrate/frame/identity", default-features = false }
+pallet-im-online = { path = "substrate/frame/im-online", default-features = false }
+pallet-indices = { path = "substrate/frame/indices", default-features = false }
+pallet-insecure-randomness-collective-flip = { path = "substrate/frame/insecure-randomness-collective-flip", default-features = false }
+pallet-lottery = { default-features = false, path = "substrate/frame/lottery" }
+pallet-membership = { path = "substrate/frame/membership", default-features = false }
+pallet-message-queue = { path = "substrate/frame/message-queue", default-features = false }
+pallet-migrations = { path = "substrate/frame/migrations", default-features = false }
+pallet-minimal-template = { path = "templates/minimal/pallets/template", default-features = false }
+pallet-mixnet = { default-features = false, path = "substrate/frame/mixnet" }
+pallet-mmr = { path = "substrate/frame/merkle-mountain-range", default-features = false }
+pallet-multisig = { path = "substrate/frame/multisig", default-features = false }
+pallet-nft-fractionalization = { path = "substrate/frame/nft-fractionalization", default-features = false }
+pallet-nfts = { path = "substrate/frame/nfts", default-features = false }
+pallet-nfts-runtime-api = { path = "substrate/frame/nfts/runtime-api", default-features = false }
+pallet-nis = { path = "substrate/frame/nis", default-features = false }
+pallet-node-authorization = { default-features = false, path = "substrate/frame/node-authorization" }
+pallet-nomination-pools = { path = "substrate/frame/nomination-pools", default-features = false }
+pallet-nomination-pools-benchmarking = { path = "substrate/frame/nomination-pools/benchmarking", default-features = false }
+pallet-nomination-pools-runtime-api = { path = "substrate/frame/nomination-pools/runtime-api", default-features = false }
+pallet-offences = { path = "substrate/frame/offences", default-features = false }
+pallet-offences-benchmarking = { path = "substrate/frame/offences/benchmarking", default-features = false }
+pallet-paged-list = { path = "substrate/frame/paged-list", default-features = false }
+pallet-parachain-template = { path = "templates/parachain/pallets/template", default-features = false }
+pallet-parameters = { path = "substrate/frame/parameters", default-features = false }
+pallet-preimage = { path = "substrate/frame/preimage", default-features = false }
+pallet-proxy = { path = "substrate/frame/proxy", default-features = false }
+pallet-ranked-collective = { path = "substrate/frame/ranked-collective", default-features = false }
+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" }
+pallet-salary = { path = "substrate/frame/salary", default-features = false }
+pallet-scheduler = { path = "substrate/frame/scheduler", default-features = false }
+pallet-scored-pool = { default-features = false, path = "substrate/frame/scored-pool" }
+pallet-session = { path = "substrate/frame/session", default-features = false }
+pallet-session-benchmarking = { path = "substrate/frame/session/benchmarking", default-features = false }
+pallet-skip-feeless-payment = { path = "substrate/frame/transaction-payment/skip-feeless-payment", default-features = false }
+pallet-society = { path = "substrate/frame/society", default-features = false }
+pallet-staking = { path = "substrate/frame/staking", default-features = false }
+pallet-staking-reward-curve = { path = "substrate/frame/staking/reward-curve", default-features = false }
+pallet-staking-reward-fn = { path = "substrate/frame/staking/reward-fn", default-features = false }
+pallet-staking-runtime-api = { path = "substrate/frame/staking/runtime-api", default-features = false }
+pallet-state-trie-migration = { path = "substrate/frame/state-trie-migration", default-features = false }
+pallet-statement = { default-features = false, path = "substrate/frame/statement" }
+pallet-sudo = { path = "substrate/frame/sudo", default-features = false }
+pallet-template = { path = "templates/solochain/pallets/template", default-features = false }
+pallet-timestamp = { path = "substrate/frame/timestamp", default-features = false }
+pallet-tips = { path = "substrate/frame/tips", default-features = false }
+pallet-transaction-payment = { path = "substrate/frame/transaction-payment", default-features = false }
+pallet-transaction-payment-rpc = { path = "substrate/frame/transaction-payment/rpc", default-features = false }
+pallet-transaction-payment-rpc-runtime-api = { path = "substrate/frame/transaction-payment/rpc/runtime-api", default-features = false }
+pallet-transaction-storage = { default-features = false, path = "substrate/frame/transaction-storage" }
+pallet-treasury = { path = "substrate/frame/treasury", default-features = false }
+pallet-tx-pause = { default-features = false, path = "substrate/frame/tx-pause" }
+pallet-uniques = { path = "substrate/frame/uniques", default-features = false }
+pallet-utility = { path = "substrate/frame/utility", default-features = false }
+pallet-vesting = { path = "substrate/frame/vesting", default-features = false }
+pallet-whitelist = { path = "substrate/frame/whitelist", default-features = false }
+pallet-xcm = { path = "polkadot/xcm/pallet-xcm", default-features = false }
+pallet-xcm-benchmarks = { path = "polkadot/xcm/pallet-xcm-benchmarks", default-features = false }
+pallet-xcm-bridge-hub = { path = "bridges/modules/xcm-bridge-hub", default-features = false }
+pallet-xcm-bridge-hub-router = { path = "bridges/modules/xcm-bridge-hub-router", default-features = false }
+parachain-info = { path = "cumulus/parachains/pallets/parachain-info", default-features = false, package = "staging-parachain-info" }
+parachain-template-runtime = { path = "templates/parachain/runtime" }
+parachains-common = { path = "cumulus/parachains/common", default-features = false }
+parachains-relay = { path = "bridges/relays/parachains" }
+parachains-runtimes-test-utils = { path = "cumulus/parachains/runtimes/test-utils", default-features = false }
+parity-bytes = { version = "0.1.2", default-features = false }
+parity-db = { version = "0.4.12" }
+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.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" }
+people-rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo" }
+people-rococo-runtime = { path = "cumulus/parachains/runtimes/people/people-rococo" }
+people-westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend" }
+people-westend-runtime = { path = "cumulus/parachains/runtimes/people/people-westend" }
+pin-project = { version = "1.1.3" }
+platforms = { version = "3.0" }
+polkadot-approval-distribution = { path = "polkadot/node/network/approval-distribution", default-features = false }
+polkadot-availability-bitfield-distribution = { path = "polkadot/node/network/bitfield-distribution", default-features = false }
+polkadot-availability-distribution = { path = "polkadot/node/network/availability-distribution", default-features = false }
+polkadot-availability-recovery = { path = "polkadot/node/network/availability-recovery", default-features = false }
+polkadot-cli = { path = "polkadot/cli", default-features = false }
+polkadot-collator-protocol = { path = "polkadot/node/network/collator-protocol", default-features = false }
+polkadot-core-primitives = { path = "polkadot/core-primitives", default-features = false }
+polkadot-dispute-distribution = { path = "polkadot/node/network/dispute-distribution", default-features = false }
+polkadot-erasure-coding = { path = "polkadot/erasure-coding", default-features = false }
+polkadot-gossip-support = { path = "polkadot/node/network/gossip-support", default-features = false }
+polkadot-network-bridge = { path = "polkadot/node/network/bridge", default-features = false }
+polkadot-node-collation-generation = { path = "polkadot/node/collation-generation", default-features = false }
+polkadot-node-core-approval-voting = { path = "polkadot/node/core/approval-voting", default-features = false }
+polkadot-node-core-av-store = { path = "polkadot/node/core/av-store", default-features = false }
+polkadot-node-core-backing = { path = "polkadot/node/core/backing", default-features = false }
+polkadot-node-core-bitfield-signing = { path = "polkadot/node/core/bitfield-signing", default-features = false }
+polkadot-node-core-candidate-validation = { path = "polkadot/node/core/candidate-validation", default-features = false }
+polkadot-node-core-chain-api = { path = "polkadot/node/core/chain-api", default-features = false }
+polkadot-node-core-chain-selection = { path = "polkadot/node/core/chain-selection", default-features = false }
+polkadot-node-core-dispute-coordinator = { path = "polkadot/node/core/dispute-coordinator", default-features = false }
+polkadot-node-core-parachains-inherent = { path = "polkadot/node/core/parachains-inherent", default-features = false }
+polkadot-node-core-prospective-parachains = { path = "polkadot/node/core/prospective-parachains", default-features = false }
+polkadot-node-core-provisioner = { path = "polkadot/node/core/provisioner", default-features = false }
+polkadot-node-core-pvf = { path = "polkadot/node/core/pvf", default-features = false }
+polkadot-node-core-pvf-checker = { path = "polkadot/node/core/pvf-checker", default-features = false }
+polkadot-node-core-pvf-common = { path = "polkadot/node/core/pvf/common", default-features = false }
+polkadot-node-core-pvf-execute-worker = { path = "polkadot/node/core/pvf/execute-worker", default-features = false }
+polkadot-node-core-pvf-prepare-worker = { path = "polkadot/node/core/pvf/prepare-worker", default-features = false }
+polkadot-node-core-runtime-api = { path = "polkadot/node/core/runtime-api", default-features = false }
+polkadot-node-jaeger = { path = "polkadot/node/jaeger", default-features = false }
+polkadot-node-metrics = { path = "polkadot/node/metrics", default-features = false }
+polkadot-node-network-protocol = { path = "polkadot/node/network/protocol", default-features = false }
+polkadot-node-primitives = { path = "polkadot/node/primitives", default-features = false }
+polkadot-node-subsystem = { path = "polkadot/node/subsystem", default-features = false }
+polkadot-node-subsystem-test-helpers = { path = "polkadot/node/subsystem-test-helpers" }
+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" }
+polkadot-rpc = { path = "polkadot/rpc", default-features = false }
+polkadot-runtime-common = { path = "polkadot/runtime/common", default-features = false }
+polkadot-runtime-metrics = { path = "polkadot/runtime/metrics", default-features = false }
+polkadot-runtime-parachains = { path = "polkadot/runtime/parachains", default-features = false }
+polkadot-sdk = { path = "umbrella", default-features = false }
+polkadot-sdk-docs = { path = "docs/sdk" }
+polkadot-service = { path = "polkadot/node/service", default-features = false }
+polkadot-statement-distribution = { path = "polkadot/node/network/statement-distribution", default-features = false }
+polkadot-statement-table = { path = "polkadot/statement-table", default-features = false }
+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 = { version = "0.9.3", default-features = false }
polkavm-derive = "0.9.1"
-log = { version = "0.4.21", default-features = false }
-quote = { version = "1.0.33" }
-serde = { version = "1.0.197", default-features = false }
+polkavm-linker = "0.9.2"
+portpicker = { version = "0.1.1" }
+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" }
+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" }
+prometheus-parse = { version = "0.2.2" }
+prost = { version = "0.12.4" }
+prost-build = { version = "0.12.4" }
+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.36" }
+rand = { version = "0.8.5", default-features = false }
+rand_chacha = { version = "0.3.1", default-features = false }
+rand_core = { version = "0.6.2" }
+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.23" }
+regex = { version = "1.10.2" }
+relay-substrate-client = { path = "bridges/relays/client-substrate" }
+relay-utils = { path = "bridges/relays/utils" }
+remote-externalities = { path = "substrate/utils/frame/remote-externalities", default-features = false, package = "frame-remote-externalities" }
+reqwest = { version = "0.11", default-features = false }
+rlp = { version = "0.5.2", default-features = false }
+rococo-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/relays/rococo" }
+rococo-parachain-runtime = { path = "cumulus/parachains/runtimes/testing/rococo-parachain" }
+rococo-runtime = { path = "polkadot/runtime/rococo" }
+rococo-runtime-constants = { path = "polkadot/runtime/rococo/constants", default-features = false }
+rococo-system-emulated-network = { path = "cumulus/parachains/integration-tests/emulated/networks/rococo-system" }
+rococo-westend-system-emulated-network = { path = "cumulus/parachains/integration-tests/emulated/networks/rococo-westend-system" }
+rpassword = { version = "7.0.0" }
+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.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 }
+sc-authority-discovery = { path = "substrate/client/authority-discovery", default-features = false }
+sc-basic-authorship = { path = "substrate/client/basic-authorship", default-features = false }
+sc-block-builder = { path = "substrate/client/block-builder", default-features = false }
+sc-chain-spec = { path = "substrate/client/chain-spec", default-features = false }
+sc-chain-spec-derive = { path = "substrate/client/chain-spec/derive", default-features = false }
+sc-cli = { path = "substrate/client/cli", default-features = false }
+sc-client-api = { path = "substrate/client/api", default-features = false }
+sc-client-db = { path = "substrate/client/db", default-features = false }
+sc-consensus = { path = "substrate/client/consensus/common", default-features = false }
+sc-consensus-aura = { path = "substrate/client/consensus/aura", default-features = false }
+sc-consensus-babe = { path = "substrate/client/consensus/babe", default-features = false }
+sc-consensus-babe-rpc = { path = "substrate/client/consensus/babe/rpc", default-features = false }
+sc-consensus-beefy = { path = "substrate/client/consensus/beefy", default-features = false }
+sc-consensus-beefy-rpc = { path = "substrate/client/consensus/beefy/rpc", default-features = false }
+sc-consensus-epochs = { path = "substrate/client/consensus/epochs", default-features = false }
+sc-consensus-grandpa = { path = "substrate/client/consensus/grandpa", default-features = false }
+sc-consensus-grandpa-rpc = { path = "substrate/client/consensus/grandpa/rpc", default-features = false }
+sc-consensus-manual-seal = { path = "substrate/client/consensus/manual-seal", default-features = false }
+sc-consensus-pow = { path = "substrate/client/consensus/pow", default-features = false }
+sc-consensus-slots = { path = "substrate/client/consensus/slots", default-features = false }
+sc-executor = { path = "substrate/client/executor", default-features = false }
+sc-executor-common = { path = "substrate/client/executor/common", default-features = false }
+sc-executor-polkavm = { path = "substrate/client/executor/polkavm", default-features = false }
+sc-executor-wasmtime = { path = "substrate/client/executor/wasmtime", default-features = false }
+sc-informant = { path = "substrate/client/informant", default-features = false }
+sc-keystore = { path = "substrate/client/keystore", default-features = false }
+sc-mixnet = { path = "substrate/client/mixnet", default-features = false }
+sc-network = { path = "substrate/client/network", default-features = false }
+sc-network-common = { path = "substrate/client/network/common", default-features = false }
+sc-network-gossip = { path = "substrate/client/network-gossip", default-features = false }
+sc-network-light = { path = "substrate/client/network/light", default-features = false }
+sc-network-statement = { default-features = false, path = "substrate/client/network/statement" }
+sc-network-sync = { path = "substrate/client/network/sync", default-features = false }
+sc-network-test = { path = "substrate/client/network/test" }
+sc-network-transactions = { path = "substrate/client/network/transactions", default-features = false }
+sc-network-types = { path = "substrate/client/network/types", default-features = false }
+sc-offchain = { path = "substrate/client/offchain", default-features = false }
+sc-proposer-metrics = { path = "substrate/client/proposer-metrics", default-features = false }
+sc-rpc = { path = "substrate/client/rpc", default-features = false }
+sc-rpc-api = { path = "substrate/client/rpc-api", default-features = false }
+sc-rpc-server = { path = "substrate/client/rpc-servers", default-features = false }
+sc-rpc-spec-v2 = { path = "substrate/client/rpc-spec-v2", default-features = false }
+sc-runtime-test = { path = "substrate/client/executor/runtime-test" }
+sc-service = { path = "substrate/client/service", default-features = false }
+sc-service-test = { path = "substrate/client/service/test" }
+sc-state-db = { path = "substrate/client/state-db", default-features = false }
+sc-statement-store = { default-features = false, path = "substrate/client/statement-store" }
+sc-storage-monitor = { path = "substrate/client/storage-monitor", default-features = false }
+sc-sync-state-rpc = { path = "substrate/client/sync-state-rpc", default-features = false }
+sc-sysinfo = { path = "substrate/client/sysinfo", default-features = false }
+sc-telemetry = { path = "substrate/client/telemetry", default-features = false }
+sc-tracing = { path = "substrate/client/tracing", default-features = false }
+sc-tracing-proc-macro = { path = "substrate/client/tracing/proc-macro", default-features = false }
+sc-transaction-pool = { path = "substrate/client/transaction-pool", default-features = false }
+sc-transaction-pool-api = { path = "substrate/client/transaction-pool/api", default-features = false }
+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" }
+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.206", 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.124", default-features = false }
serde_yaml = { version = "0.9" }
+serial_test = { version = "2.0.0" }
+sha1 = { version = "0.10.6" }
+sha2 = { version = "0.10.7", default-features = false }
+sha3 = { version = "0.10.0", default-features = false }
+shell-runtime = { path = "cumulus/parachains/runtimes/starters/shell" }
+slot-range-helper = { path = "polkadot/runtime/common/slot_range_helper", default-features = false }
+slotmap = { version = "1.0" }
+smallvec = { version = "1.11.0", default-features = false }
+smoldot = { version = "0.11.0", default-features = false }
+smoldot-light = { version = "0.9.0", default-features = false }
+snowbridge-beacon-primitives = { path = "bridges/snowbridge/primitives/beacon", default-features = false }
+snowbridge-core = { path = "bridges/snowbridge/primitives/core", default-features = false }
+snowbridge-ethereum = { path = "bridges/snowbridge/primitives/ethereum", default-features = false }
+snowbridge-outbound-queue-merkle-tree = { path = "bridges/snowbridge/pallets/outbound-queue/merkle-tree", default-features = false }
+snowbridge-outbound-queue-runtime-api = { path = "bridges/snowbridge/pallets/outbound-queue/runtime-api", default-features = false }
+snowbridge-pallet-ethereum-client = { path = "bridges/snowbridge/pallets/ethereum-client", default-features = false }
+snowbridge-pallet-ethereum-client-fixtures = { path = "bridges/snowbridge/pallets/ethereum-client/fixtures", default-features = false }
+snowbridge-pallet-inbound-queue = { path = "bridges/snowbridge/pallets/inbound-queue", default-features = false }
+snowbridge-pallet-inbound-queue-fixtures = { path = "bridges/snowbridge/pallets/inbound-queue/fixtures", default-features = false }
+snowbridge-pallet-outbound-queue = { path = "bridges/snowbridge/pallets/outbound-queue", default-features = false }
+snowbridge-pallet-system = { path = "bridges/snowbridge/pallets/system", default-features = false }
+snowbridge-router-primitives = { path = "bridges/snowbridge/primitives/router", default-features = false }
+snowbridge-runtime-common = { path = "bridges/snowbridge/runtime/runtime-common", default-features = false }
+snowbridge-runtime-test-common = { path = "bridges/snowbridge/runtime/test-common", default-features = false }
+snowbridge-system-runtime-api = { path = "bridges/snowbridge/pallets/system/runtime-api", default-features = false }
+soketto = { version = "0.7.1" }
+solochain-template-runtime = { path = "templates/solochain/runtime" }
+sp-api = { path = "substrate/primitives/api", default-features = false }
+sp-api-proc-macro = { path = "substrate/primitives/api/proc-macro", default-features = false }
+sp-application-crypto = { path = "substrate/primitives/application-crypto", default-features = false }
+sp-arithmetic = { path = "substrate/primitives/arithmetic", default-features = false }
+sp-authority-discovery = { path = "substrate/primitives/authority-discovery", default-features = false }
+sp-block-builder = { path = "substrate/primitives/block-builder", default-features = false }
+sp-blockchain = { path = "substrate/primitives/blockchain", default-features = false }
+sp-consensus = { path = "substrate/primitives/consensus/common", default-features = false }
+sp-consensus-aura = { path = "substrate/primitives/consensus/aura", default-features = false }
+sp-consensus-babe = { path = "substrate/primitives/consensus/babe", default-features = false }
+sp-consensus-beefy = { path = "substrate/primitives/consensus/beefy", default-features = false }
+sp-consensus-grandpa = { path = "substrate/primitives/consensus/grandpa", default-features = false }
+sp-consensus-pow = { path = "substrate/primitives/consensus/pow", default-features = false }
+sp-consensus-sassafras = { path = "substrate/primitives/consensus/sassafras", default-features = false }
+sp-consensus-slots = { path = "substrate/primitives/consensus/slots", default-features = false }
+sp-core = { path = "substrate/primitives/core", default-features = false }
+sp-core-hashing = { default-features = false, path = "substrate/deprecated/hashing" }
+sp-core-hashing-proc-macro = { default-features = false, path = "substrate/deprecated/hashing/proc-macro" }
+sp-crypto-ec-utils = { default-features = false, path = "substrate/primitives/crypto/ec-utils" }
+sp-crypto-hashing = { path = "substrate/primitives/crypto/hashing", default-features = false }
+sp-crypto-hashing-proc-macro = { path = "substrate/primitives/crypto/hashing/proc-macro", default-features = false }
+sp-database = { path = "substrate/primitives/database", default-features = false }
+sp-debug-derive = { path = "substrate/primitives/debug-derive", default-features = false }
+sp-externalities = { path = "substrate/primitives/externalities", default-features = false }
+sp-genesis-builder = { path = "substrate/primitives/genesis-builder", default-features = false }
+sp-inherents = { path = "substrate/primitives/inherents", default-features = false }
+sp-io = { path = "substrate/primitives/io", default-features = false }
+sp-keyring = { path = "substrate/primitives/keyring", default-features = false }
+sp-keystore = { path = "substrate/primitives/keystore", default-features = false }
+sp-maybe-compressed-blob = { path = "substrate/primitives/maybe-compressed-blob", default-features = false }
+sp-metadata-ir = { path = "substrate/primitives/metadata-ir", default-features = false }
+sp-mixnet = { path = "substrate/primitives/mixnet", default-features = false }
+sp-mmr-primitives = { path = "substrate/primitives/merkle-mountain-range", default-features = false }
+sp-npos-elections = { path = "substrate/primitives/npos-elections", default-features = false }
+sp-offchain = { path = "substrate/primitives/offchain", default-features = false }
+sp-panic-handler = { path = "substrate/primitives/panic-handler", default-features = false }
+sp-rpc = { path = "substrate/primitives/rpc", default-features = false }
+sp-runtime = { path = "substrate/primitives/runtime", default-features = false }
+sp-runtime-interface = { path = "substrate/primitives/runtime-interface", default-features = false }
+sp-runtime-interface-proc-macro = { path = "substrate/primitives/runtime-interface/proc-macro", default-features = false }
+sp-runtime-interface-test-wasm = { path = "substrate/primitives/runtime-interface/test-wasm" }
+sp-runtime-interface-test-wasm-deprecated = { path = "substrate/primitives/runtime-interface/test-wasm-deprecated" }
+sp-session = { path = "substrate/primitives/session", default-features = false }
+sp-staking = { path = "substrate/primitives/staking", default-features = false }
+sp-state-machine = { path = "substrate/primitives/state-machine", default-features = false }
+sp-statement-store = { path = "substrate/primitives/statement-store", default-features = false }
+sp-std = { path = "substrate/primitives/std", default-features = false }
+sp-storage = { path = "substrate/primitives/storage", default-features = false }
+sp-test-primitives = { path = "substrate/primitives/test-primitives" }
+sp-timestamp = { path = "substrate/primitives/timestamp", default-features = false }
+sp-tracing = { path = "substrate/primitives/tracing", default-features = false }
+sp-transaction-pool = { path = "substrate/primitives/transaction-pool", default-features = false }
+sp-transaction-storage-proof = { path = "substrate/primitives/transaction-storage-proof", default-features = false }
+sp-trie = { path = "substrate/primitives/trie", default-features = false }
+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.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 }
+static_assertions = { version = "1.1.0", default-features = false }
+static_init = { version = "1.0.3" }
+structopt = { version = "0.3" }
+strum = { version = "0.26.2", default-features = false }
+subkey = { path = "substrate/bin/utils/subkey", default-features = false }
+substrate-bip39 = { path = "substrate/utils/substrate-bip39", default-features = false }
+substrate-build-script-utils = { path = "substrate/utils/build-script-utils", default-features = false }
+substrate-cli-test-utils = { path = "substrate/test-utils/cli" }
+substrate-frame-rpc-support = { default-features = false, path = "substrate/utils/frame/rpc/support" }
+substrate-frame-rpc-system = { path = "substrate/utils/frame/rpc/system", default-features = false }
+substrate-rpc-client = { path = "substrate/utils/frame/rpc/client", default-features = false }
+substrate-state-trie-migration-rpc = { path = "substrate/utils/frame/rpc/state-trie-migration-rpc", default-features = false }
+substrate-test-client = { path = "substrate/test-utils/client" }
+substrate-test-runtime = { path = "substrate/test-utils/runtime" }
+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" }
+sysinfo = { version = "0.30" }
+tar = { version = "0.4" }
+tempfile = { version = "3.8.1" }
+test-log = { version = "0.2.14" }
+test-pallet = { path = "substrate/frame/support/test/pallet", default-features = false, package = "frame-support-test-pallet" }
+test-parachain-adder = { path = "polkadot/parachain/test-parachains/adder" }
+test-parachain-halt = { path = "polkadot/parachain/test-parachains/halt" }
+test-parachain-undying = { path = "polkadot/parachain/test-parachains/undying" }
+test-runtime-constants = { path = "polkadot/runtime/test-runtime/constants", default-features = false }
+testnet-parachains-constants = { path = "cumulus/parachains/runtimes/constants", default-features = false }
thiserror = { version = "1.0.48" }
+thousands = { version = "0.2.0" }
+threadpool = { version = "1.7" }
+tikv-jemalloc-ctl = { version = "0.5.0" }
+tikv-jemallocator = { version = "0.5.0" }
+time = { version = "0.3" }
+tiny-keccak = { version = "2.0.2" }
+tokio = { version = "1.37.0", default-features = false }
+tokio-retry = { version = "0.3.0" }
+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_edit = { version = "0.19" }
+tower = { version = "0.4.13" }
+tower-http = { version = "0.5.2" }
+tracing = { version = "0.1.37", default-features = false }
+tracing-core = { version = "0.1.32", default-features = false }
+tracing-futures = { version = "0.2.4" }
+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.1", default-features = false }
+trie-root = { version = "0.18.0", default-features = false }
+trie-standardmap = { version = "0.16.0" }
+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 }
+unsigned-varint = { version = "0.7.2" }
+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.5.0" }
+wasm-bindgen-test = { version = "0.3.19" }
+wasm-instrument = { version = "0.4", default-features = false }
+wasm-opt = { version = "0.116" }
+wasm-timer = { version = "0.2.5" }
+wasmi = { version = "0.32.3", default-features = false }
+wasmtime = { version = "8.0.1", default-features = false }
+wat = { version = "1.0.0" }
+westend-emulated-chain = { path = "cumulus/parachains/integration-tests/emulated/chains/relays/westend", default-features = false }
+westend-runtime = { path = "polkadot/runtime/westend" }
+westend-runtime-constants = { path = "polkadot/runtime/westend/constants", default-features = false }
+westend-system-emulated-network = { path = "cumulus/parachains/integration-tests/emulated/networks/westend-system" }
+x25519-dalek = { version = "2.0" }
+xcm = { path = "polkadot/xcm", default-features = false, package = "staging-xcm" }
+xcm-builder = { path = "polkadot/xcm/xcm-builder", default-features = false, package = "staging-xcm-builder" }
+xcm-docs = { path = "polkadot/xcm/docs" }
+xcm-emulator = { path = "cumulus/xcm/xcm-emulator", default-features = false }
+xcm-executor = { path = "polkadot/xcm/xcm-executor", default-features = false, package = "staging-xcm-executor" }
+xcm-procedural = { path = "polkadot/xcm/procedural", default-features = false }
+xcm-runtime-apis = { path = "polkadot/xcm/xcm-runtime-apis", default-features = false }
+xcm-simulator = { path = "polkadot/xcm/xcm-simulator", default-features = false }
+zeroize = { version = "1.7.0", default-features = false }
+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 773481732520e2a8c9217e72e426a9bda781fb6f..34d657194daa67de18088fb04d3ae878421c6d9f 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,11 +18,21 @@ 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)
- * [Introduction](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/index.html)
- to each component of the Polkadot SDK: Substrate, FRAME, Cumulus, and XCM
+ * [Introduction](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/index.html)
+ to each component of the Polkadot SDK: Substrate, FRAME, Cumulus, and XCM
+ * [Guides](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/index.html),
+ namely how to build your first FRAME pallet.
+ * [Templates](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/templates/index.html)
+ for starting a new project.
* Other Resources:
* [Polkadot Wiki -> Build](https://wiki.polkadot.network/docs/build-guide)
@@ -39,6 +46,9 @@ The Polkadot-SDK has two release channels: `stable` and `nightly`. Production so
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
@@ -50,6 +60,12 @@ non-breaking features on a **two week** cadence.
`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`.
+## ๐ ๏ธ Tooling
+
+[Polkadot SDK Version Manager](https://github.com/paritytech/psvm):
+A simple tool to manage and update the Polkadot SDK dependencies in any Cargo.toml file.
+It will automatically update the Polkadot SDK dependencies to their correct crates.io version.
+
## ๐ Security
The security policy and procedures can be found in
diff --git a/bridges/bin/runtime-common/Cargo.toml b/bridges/bin/runtime-common/Cargo.toml
index 783009a8c890768bcc85dafec14dc3da9e8da573..36f27b6aa0358fcb8027bbfe6e571bc1a50962e6 100644
--- a/bridges/bin/runtime-common/Cargo.toml
+++ b/bridges/bin/runtime-common/Cargo.toml
@@ -11,48 +11,44 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
-hash-db = { version = "0.16.0", default-features = false }
+codec = { features = ["derive"], workspace = true }
log = { workspace = true }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
-static_assertions = { version = "1.1", optional = true }
-tuplex = { version = "0.1", default-features = false }
+scale-info = { features = ["derive"], workspace = true }
+static_assertions = { optional = true, workspace = true, default-features = true }
+tuplex = { workspace = true }
# Bridge dependencies
-
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
-bp-parachains = { path = "../../primitives/parachains", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-relayers = { path = "../../primitives/relayers", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-xcm-bridge-hub = { path = "../../primitives/xcm-bridge-hub", default-features = false }
-bp-xcm-bridge-hub-router = { path = "../../primitives/xcm-bridge-hub-router", default-features = false }
-pallet-bridge-grandpa = { path = "../../modules/grandpa", default-features = false }
-pallet-bridge-messages = { path = "../../modules/messages", default-features = false }
-pallet-bridge-parachains = { path = "../../modules/parachains", default-features = false }
-pallet-bridge-relayers = { path = "../../modules/relayers", default-features = false }
+bp-header-chain = { workspace = true }
+bp-messages = { workspace = true }
+bp-parachains = { workspace = true }
+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 = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false }
-pallet-utility = { path = "../../../substrate/frame/utility", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-core = { path = "../../../substrate/primitives/core", default-features = false }
-sp-io = { path = "../../../substrate/primitives/io", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
-sp-trie = { path = "../../../substrate/primitives/trie", default-features = false }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+pallet-transaction-payment = { workspace = true }
+pallet-utility = { workspace = true }
+sp-io = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+sp-trie = { optional = true, workspace = true }
# Polkadot dependencies
-xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false }
-xcm-builder = { package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder", default-features = false }
+xcm = { workspace = true }
+xcm-builder = { workspace = true }
[dev-dependencies]
-bp-test-utils = { path = "../../primitives/test-utils" }
-pallet-balances = { path = "../../../substrate/frame/balances" }
+bp-test-utils = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-bridge-messages = { features = ["std", "test-helpers"], workspace = true }
[features]
default = ["std"]
@@ -63,13 +59,14 @@ std = [
"bp-polkadot-core/std",
"bp-relayers/std",
"bp-runtime/std",
+ "bp-test-utils/std",
"bp-xcm-bridge-hub-router/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,8 +74,6 @@ 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",
@@ -88,15 +83,22 @@ 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",
+ "sp-trie",
"xcm-builder/runtime-benchmarks",
]
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/check_obsolete_extension.rs
index 2c152aef68226aee36e791a882b5859427a9a33d..df75092af6e8b89fb76003cf0bfff508214ea825 100644
--- a/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
+++ b/bridges/bin/runtime-common/src/extensions/check_obsolete_extension.rs
@@ -36,6 +36,12 @@ use sp_runtime::{
transaction_validity::{TransactionPriority, TransactionValidity, ValidTransactionBuilder},
};
+// Re-export to avoid include tuplex dependency everywhere.
+#[doc(hidden)]
+pub mod __private {
+ pub use tuplex;
+}
+
/// A duplication of the `FilterCall` trait.
///
/// We need this trait in order to be able to implement it for the messages pallet,
@@ -313,7 +319,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
info: &sp_runtime::traits::DispatchInfoOf,
len: usize,
) -> Result {
- use tuplex::PushBack;
+ use $crate::extensions::check_obsolete_extension::__private::tuplex::PushBack;
let to_post_dispatch = ();
$(
let (from_validate, call_filter_validity) = <
@@ -336,7 +342,7 @@ macro_rules! generate_bridge_reject_obsolete_headers_and_messages {
len: usize,
result: &sp_runtime::DispatchResult,
) -> Result<(), sp_runtime::transaction_validity::TransactionValidityError> {
- use tuplex::PopFront;
+ use $crate::extensions::check_obsolete_extension::__private::tuplex::PopFront;
let Some((relayer, to_post_dispatch)) = to_post_dispatch else { return Ok(()) };
let has_failed = result.is_err();
$(
diff --git a/bridges/bin/runtime-common/src/extensions/priority_calculator.rs b/bridges/bin/runtime-common/src/extensions/priority_calculator.rs
index 92810290f95e77a7fdc04cafaa1e6ab290e1661a..9f559dc13b64d3912f0d1679c21fa682034bdb8e 100644
--- a/bridges/bin/runtime-common/src/extensions/priority_calculator.rs
+++ b/bridges/bin/runtime-common/src/extensions/priority_calculator.rs
@@ -319,6 +319,7 @@ mod integrity_tests {
pub mod per_message {
use super::*;
+ use bp_messages::ChainWithMessages;
use pallet_bridge_messages::WeightInfoExt;
/// Ensures that the value of `PriorityBoostPerMessage` matches the value of
@@ -339,7 +340,7 @@ mod integrity_tests {
BalanceOf: Send + Sync + FixedPointOperand,
{
let maximal_messages_in_delivery_transaction =
- Runtime::MaxUnconfirmedMessagesAtInboundLane::get();
+ Runtime::BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX;
super::ensure_priority_boost_is_sane::>(
"PriorityBoostPerMessage",
maximal_messages_in_delivery_transaction,
diff --git a/bridges/bin/runtime-common/src/extensions/refund_relayer_extension.rs b/bridges/bin/runtime-common/src/extensions/refund_relayer_extension.rs
index 5aa7f1c095d540a4ee5050aeb7d694c98b744683..6ba3506377d0e602bf9ee706b13c248efd6afaca 100644
--- a/bridges/bin/runtime-common/src/extensions/refund_relayer_extension.rs
+++ b/bridges/bin/runtime-common/src/extensions/refund_relayer_extension.rs
@@ -22,9 +22,9 @@
use crate::messages_call_ext::{
CallHelper as MessagesCallHelper, CallInfo as MessagesCallInfo, MessagesCallSubType,
};
-use bp_messages::{LaneId, MessageNonce};
+use bp_messages::{ChainWithMessages, LaneId, MessageNonce};
use bp_relayers::{ExplicitOrAccountParams, RewardsAccountOwner, RewardsAccountParams};
-use bp_runtime::{Parachain, RangeInclusiveExt, StaticStrProvider};
+use bp_runtime::{Chain, Parachain, RangeInclusiveExt, StaticStrProvider};
use codec::{Codec, Decode, Encode};
use frame_support::{
dispatch::{CallableCallFor, DispatchInfo, PostDispatchInfo},
@@ -293,7 +293,7 @@ pub trait RefundSignedExtension:
::Id::get(),
::Instance,
- >>::BridgedChainId::get(),
+ >>::BridgedChain::ID,
if call_info.is_receive_messages_proof_call() {
RewardsAccountOwner::ThisChain
} else {
@@ -406,8 +406,7 @@ pub trait RefundSignedExtension:
// a quick check to avoid invalid high-priority transactions
let max_unconfirmed_messages_in_confirmation_tx = ::Instance,
- >>::MaxUnconfirmedMessagesAtInboundLane::get(
- );
+ >>::BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX;
if bundled_messages > max_unconfirmed_messages_in_confirmation_tx {
return None
}
@@ -935,9 +934,6 @@ where
pub(crate) mod tests {
use super::*;
use crate::{
- messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
- },
messages_call_ext::{
BaseMessagesProofInfo, ReceiveMessagesDeliveryProofInfo, ReceiveMessagesProofInfo,
UnrewardedRelayerOccupation,
@@ -946,8 +942,10 @@ pub(crate) mod tests {
};
use bp_header_chain::StoredHeaderDataBuilder;
use bp_messages::{
- DeliveredMessages, InboundLaneData, MessageNonce, MessagesOperatingMode, OutboundLaneData,
- UnrewardedRelayer, UnrewardedRelayersState,
+ source_chain::FromBridgedChainMessagesDeliveryProof,
+ target_chain::FromBridgedChainMessagesProof, DeliveredMessages, InboundLaneData,
+ MessageNonce, MessagesOperatingMode, OutboundLaneData, UnrewardedRelayer,
+ UnrewardedRelayersState,
};
use bp_parachains::{BestParaHeadHash, ParaInfo};
use bp_polkadot_core::parachains::{ParaHeadsProof, ParaId};
@@ -1123,7 +1121,7 @@ pub(crate) mod tests {
ParaId(BridgedUnderlyingParachain::PARACHAIN_ID),
[parachain_head_at_relay_header_number as u8; 32].into(),
)],
- parachain_heads_proof: ParaHeadsProof { storage_proof: vec![] },
+ parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() },
})
}
@@ -1136,7 +1134,7 @@ pub(crate) mod tests {
ParaId(BridgedUnderlyingParachain::PARACHAIN_ID),
[parachain_head_at_relay_header_number as u8; 32].into(),
)],
- parachain_heads_proof: ParaHeadsProof { storage_proof: vec![] },
+ parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() },
is_free_execution_expected: false,
})
}
@@ -1144,9 +1142,9 @@ pub(crate) mod tests {
fn message_delivery_call(best_message: MessageNonce) -> RuntimeCall {
RuntimeCall::BridgeMessages(MessagesCall::receive_messages_proof {
relayer_id_at_bridged_chain: relayer_account_at_bridged_chain(),
- proof: FromBridgedChainMessagesProof {
+ proof: Box::new(FromBridgedChainMessagesProof {
bridged_header_hash: Default::default(),
- storage_proof: vec![],
+ storage_proof: Default::default(),
lane: TestLaneId::get(),
nonces_start: pallet_bridge_messages::InboundLanes::::get(
TEST_LANE_ID,
@@ -1154,7 +1152,7 @@ pub(crate) mod tests {
.last_delivered_nonce() +
1,
nonces_end: best_message,
- },
+ }),
messages_count: 1,
dispatch_weight: Weight::zero(),
})
@@ -1164,7 +1162,7 @@ pub(crate) mod tests {
RuntimeCall::BridgeMessages(MessagesCall::receive_messages_delivery_proof {
proof: FromBridgedChainMessagesDeliveryProof {
bridged_header_hash: Default::default(),
- storage_proof: vec![],
+ storage_proof: Default::default(),
lane: TestLaneId::get(),
},
relayers_state: UnrewardedRelayersState {
@@ -1327,8 +1325,10 @@ pub(crate) mod tests {
best_stored_nonce: 100,
},
unrewarded_relayers: UnrewardedRelayerOccupation {
- free_relayer_slots: MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- free_message_slots: MaxUnconfirmedMessagesAtInboundLane::get(),
+ free_relayer_slots:
+ BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
+ free_message_slots:
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
}),
),
@@ -1397,8 +1397,10 @@ pub(crate) mod tests {
best_stored_nonce: 100,
},
unrewarded_relayers: UnrewardedRelayerOccupation {
- free_relayer_slots: MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- free_message_slots: MaxUnconfirmedMessagesAtInboundLane::get(),
+ free_relayer_slots:
+ BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
+ free_message_slots:
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
}),
),
@@ -1459,8 +1461,10 @@ pub(crate) mod tests {
best_stored_nonce: 100,
},
unrewarded_relayers: UnrewardedRelayerOccupation {
- free_relayer_slots: MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- free_message_slots: MaxUnconfirmedMessagesAtInboundLane::get(),
+ free_relayer_slots:
+ BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
+ free_message_slots:
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
}),
),
@@ -1499,8 +1503,10 @@ pub(crate) mod tests {
best_stored_nonce: 100,
},
unrewarded_relayers: UnrewardedRelayerOccupation {
- free_relayer_slots: MaxUnrewardedRelayerEntriesAtInboundLane::get(),
- free_message_slots: MaxUnconfirmedMessagesAtInboundLane::get(),
+ free_relayer_slots:
+ BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX,
+ free_message_slots:
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
},
)),
@@ -1735,14 +1741,16 @@ pub(crate) mod tests {
let fns = [run_validate, run_grandpa_validate, run_messages_validate];
for f in fns {
- let priority_of_max_messages_delivery =
- f(message_delivery_call(100 + MaxUnconfirmedMessagesAtInboundLane::get()))
- .unwrap()
- .priority;
- let priority_of_more_than_max_messages_delivery =
- f(message_delivery_call(100 + MaxUnconfirmedMessagesAtInboundLane::get() + 1))
- .unwrap()
- .priority;
+ let priority_of_max_messages_delivery = f(message_delivery_call(
+ 100 + BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
+ ))
+ .unwrap()
+ .priority;
+ let priority_of_more_than_max_messages_delivery = f(message_delivery_call(
+ 100 + BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX + 1,
+ ))
+ .unwrap()
+ .priority;
assert!(
priority_of_max_messages_delivery > priority_of_more_than_max_messages_delivery,
@@ -2103,7 +2111,7 @@ pub(crate) mod tests {
[1u8; 32].into(),
),
],
- parachain_heads_proof: ParaHeadsProof { storage_proof: vec![] },
+ parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() },
}),
message_delivery_call(200),
],
@@ -2865,7 +2873,8 @@ pub(crate) mod tests {
#[test]
fn does_not_panic_on_boosting_priority_of_empty_message_delivery_transaction() {
run_test(|| {
- let best_delivered_message = MaxUnconfirmedMessagesAtInboundLane::get();
+ let best_delivered_message =
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX;
initialize_environment(100, 100, best_delivered_message);
// register relayer so it gets priority boost
diff --git a/bridges/bin/runtime-common/src/integrity.rs b/bridges/bin/runtime-common/src/integrity.rs
index d3827a14dd6cc24e088a8d05d26aba9d769eb213..a0a9367dd1400309d0f0be967665a4543ad982cb 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::messages_xcm_extension::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 MessagesConfig;
+
// 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>>::ThisChain, $this);
+ assert_type_eq_all!(<$r as MessagesConfig<$i>>::BridgedChain, $bridged);
- assert_type_eq_all!(<$r as MessagesConfig<$i>>::InboundRelayer, AccountIdOf>);
-
- 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 MessagesConfig<$i>>::OutboundPayload, XcmAsPlainPayload);
+ assert_type_eq_all!(<$r as MessagesConfig<$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,20 +168,8 @@ 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,
@@ -207,27 +179,22 @@ where
"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 +205,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 +233,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 +302,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..b65bb6041d5610ce2bdfb63f923f3f24b21dcd7f 100644
--- a/bridges/bin/runtime-common/src/lib.rs
+++ b/bridges/bin/runtime-common/src/lib.rs
@@ -20,11 +20,10 @@
#![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;
diff --git a/bridges/bin/runtime-common/src/messages.rs b/bridges/bin/runtime-common/src/messages.rs
deleted file mode 100644
index 0fe9935dbdb6dfc776977ff8cfbad87d3eee9f6e..0000000000000000000000000000000000000000
--- a/bridges/bin/runtime-common/src/messages.rs
+++ /dev/null
@@ -1,701 +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 _;
-
- #[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::DuplicateNodesInProof
- ))),
- );
- }
-
- #[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::UnusedNodesInTheProof)),
- );
- }
-
- #[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_call_ext.rs b/bridges/bin/runtime-common/src/messages_call_ext.rs
index fb07f7b6dd69110918af23b227708e226bede625..a9ee1969ae0ca462f36098f03b4454e1399af129 100644
--- a/bridges/bin/runtime-common/src/messages_call_ext.rs
+++ b/bridges/bin/runtime-common/src/messages_call_ext.rs
@@ -14,19 +14,14 @@
// You should have received a copy of the GNU General Public License
// along with Parity Bridges Common. If not, see , I: 'static>:
}
impl<
- BridgedHeaderHash,
- SourceHeaderChain: bp_messages::target_chain::SourceHeaderChain<
- MessagesProof = FromBridgedChainMessagesProof,
- >,
- TargetHeaderChain: bp_messages::source_chain::TargetHeaderChain<
- >::OutboundPayload,
- ::AccountId,
- MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof,
- >,
Call: IsSubType, T>>,
- T: frame_system::Config
- + Config,
+ T: frame_system::Config + Config,
I: 'static,
> MessagesCallSubType for T::RuntimeCall
{
@@ -340,16 +325,17 @@ impl<
/// Returns occupation state of unrewarded relayers vector.
fn unrewarded_relayers_occupation, I: 'static>(
- inbound_lane_data: &InboundLaneData,
+ inbound_lane_data: &InboundLaneData>>,
) -> UnrewardedRelayerOccupation {
UnrewardedRelayerOccupation {
- free_relayer_slots: T::MaxUnrewardedRelayerEntriesAtInboundLane::get()
+ free_relayer_slots: T::BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX
.saturating_sub(inbound_lane_data.relayers.len() as MessageNonce),
free_message_slots: {
let unconfirmed_messages = inbound_lane_data
.last_delivered_nonce()
.saturating_sub(inbound_lane_data.last_confirmed_nonce);
- T::MaxUnconfirmedMessagesAtInboundLane::get().saturating_sub(unconfirmed_messages)
+ T::BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX
+ .saturating_sub(unconfirmed_messages)
},
}
}
@@ -358,22 +344,20 @@ fn unrewarded_relayers_occupation, I: 'static>(
mod tests {
use super::*;
use crate::{
- messages::{
- source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof,
- },
messages_call_ext::MessagesCallSubType,
- mock::{
- DummyMessageDispatch, MaxUnconfirmedMessagesAtInboundLane,
- MaxUnrewardedRelayerEntriesAtInboundLane, TestRuntime, ThisChainRuntimeCall,
- },
+ mock::{BridgedUnderlyingChain, DummyMessageDispatch, TestRuntime, ThisChainRuntimeCall},
+ };
+ use bp_messages::{
+ source_chain::FromBridgedChainMessagesDeliveryProof,
+ target_chain::FromBridgedChainMessagesProof, DeliveredMessages, UnrewardedRelayer,
+ UnrewardedRelayersState,
};
- use bp_messages::{DeliveredMessages, UnrewardedRelayer, UnrewardedRelayersState};
use sp_std::ops::RangeInclusive;
fn fill_unrewarded_relayers() {
let mut inbound_lane_state =
pallet_bridge_messages::InboundLanes::::get(LaneId([0, 0, 0, 0]));
- for n in 0..MaxUnrewardedRelayerEntriesAtInboundLane::get() {
+ for n in 0..BridgedUnderlyingChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX {
inbound_lane_state.relayers.push_back(UnrewardedRelayer {
relayer: Default::default(),
messages: DeliveredMessages { begin: n + 1, end: n + 1 },
@@ -392,7 +376,7 @@ mod tests {
relayer: Default::default(),
messages: DeliveredMessages {
begin: 1,
- end: MaxUnconfirmedMessagesAtInboundLane::get(),
+ end: BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
},
});
pallet_bridge_messages::InboundLanes::::insert(
@@ -418,13 +402,13 @@ mod tests {
messages_count: nonces_end.checked_sub(nonces_start).map(|x| x + 1).unwrap_or(0)
as u32,
dispatch_weight: frame_support::weights::Weight::zero(),
- proof: FromBridgedChainMessagesProof {
+ proof: Box::new(FromBridgedChainMessagesProof {
bridged_header_hash: Default::default(),
- storage_proof: vec![],
+ storage_proof: Default::default(),
lane: LaneId([0, 0, 0, 0]),
nonces_start,
nonces_end,
- },
+ }),
},
)
.check_obsolete_call()
@@ -508,8 +492,8 @@ mod tests {
sp_io::TestExternalities::new(Default::default()).execute_with(|| {
fill_unrewarded_messages();
assert!(validate_message_delivery(
- MaxUnconfirmedMessagesAtInboundLane::get(),
- MaxUnconfirmedMessagesAtInboundLane::get() - 1
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX,
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX - 1
));
});
}
@@ -540,7 +524,7 @@ mod tests {
pallet_bridge_messages::Call::::receive_messages_delivery_proof {
proof: FromBridgedChainMessagesDeliveryProof {
bridged_header_hash: Default::default(),
- storage_proof: Vec::new(),
+ storage_proof: Default::default(),
lane: LaneId([0, 0, 0, 0]),
},
relayers_state: UnrewardedRelayersState {
@@ -608,7 +592,7 @@ mod tests {
free_message_slots: if is_empty {
0
} else {
- MaxUnconfirmedMessagesAtInboundLane::get()
+ BridgedUnderlyingChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX
},
},
},
diff --git a/bridges/bin/runtime-common/src/mock.rs b/bridges/bin/runtime-common/src/mock.rs
index f49474667896049cfd6aff4bf4a4b0d9d6e73c95..2f248a7162a6cbdcc09d2980a922b1a065127e40 100644
--- a/bridges/bin/runtime-common/src/mock.rs
+++ b/bridges/bin/runtime-common/src/mock.rs
@@ -18,26 +18,16 @@
#![cfg(test)]
-use crate::messages::{
- source::{
- FromThisChainMaximalOutboundPayloadSize, FromThisChainMessagePayload,
- TargetHeaderChainAdapter,
- },
- target::{FromBridgedChainMessagePayload, SourceHeaderChainAdapter},
- BridgedChainWithMessages, HashOf, MessageBridge, ThisChainWithMessages,
-};
+use crate::messages_xcm_extension::XcmAsPlainPayload;
-use bp_header_chain::{ChainWithGrandpa, HeaderChain};
+use bp_header_chain::ChainWithGrandpa;
use bp_messages::{
target_chain::{DispatchMessage, MessageDispatch},
- LaneId, MessageNonce,
+ ChainWithMessages, LaneId, MessageNonce,
};
use bp_parachains::SingleParaStoredHeaderDataBuilder;
use bp_relayers::PayRewardFromAccount;
-use bp_runtime::{
- messages::MessageDispatchResult, Chain, ChainId, Parachain, UnderlyingChainProvider,
-};
-use codec::{Decode, Encode};
+use bp_runtime::{messages::MessageDispatchResult, Chain, ChainId, Parachain};
use frame_support::{
derive_impl, parameter_types,
weights::{ConstantMultiplier, IdentityFee, RuntimeDbWeight, Weight},
@@ -46,7 +36,7 @@ use pallet_transaction_payment::Multiplier;
use sp_runtime::{
testing::H256,
traits::{BlakeTwo256, ConstU32, ConstU64, ConstU8},
- FixedPointNumber, Perquintill,
+ FixedPointNumber, Perquintill, StateVersion,
};
/// Account identifier at `ThisChain`.
@@ -61,8 +51,6 @@ pub type ThisChainHash = H256;
pub type ThisChainHasher = BlakeTwo256;
/// Runtime call at `ThisChain`.
pub type ThisChainRuntimeCall = RuntimeCall;
-/// Runtime call origin at `ThisChain`.
-pub type ThisChainCallOrigin = RuntimeOrigin;
/// Header of `ThisChain`.
pub type ThisChainHeader = sp_runtime::generic::Header;
/// Block of `ThisChain`.
@@ -100,8 +88,6 @@ pub type TestStakeAndSlash = pallet_bridge_relayers::StakeAndSlashNamed<
pub const TEST_LANE_ID: LaneId = LaneId([0, 0, 0, 0]);
/// Bridged chain id used in tests.
pub const TEST_BRIDGED_CHAIN_ID: ChainId = *b"brdg";
-/// Maximal extrinsic weight at the `BridgedChain`.
-pub const BRIDGED_CHAIN_MAX_EXTRINSIC_WEIGHT: usize = 2048;
/// Maximal extrinsic size at the `BridgedChain`.
pub const BRIDGED_CHAIN_MAX_EXTRINSIC_SIZE: u32 = 1024;
@@ -126,7 +112,6 @@ crate::generate_bridge_reject_obsolete_headers_and_messages! {
parameter_types! {
pub const ActiveOutboundLanes: &'static [LaneId] = &[TEST_LANE_ID];
- pub const BridgedChainId: ChainId = TEST_BRIDGED_CHAIN_ID;
pub const BridgedParasPalletName: &'static str = "Paras";
pub const ExistentialDeposit: ThisChainBalance = 500;
pub const DbWeight: RuntimeDbWeight = RuntimeDbWeight { read: 1, write: 2 };
@@ -136,8 +121,6 @@ parameter_types! {
pub AdjustmentVariable: Multiplier = Multiplier::saturating_from_rational(3, 100_000);
pub MinimumMultiplier: Multiplier = Multiplier::saturating_from_rational(1, 1_000_000u128);
pub MaximumMultiplier: Multiplier = sp_runtime::traits::Bounded::max_value();
- pub const MaxUnrewardedRelayerEntriesAtInboundLane: MessageNonce = 16;
- pub const MaxUnconfirmedMessagesAtInboundLane: MessageNonce = 1_000;
pub const ReserveId: [u8; 8] = *b"brdgrlrs";
}
@@ -203,17 +186,12 @@ impl pallet_bridge_messages::Config for TestRuntime {
type RuntimeEvent = RuntimeEvent;
type WeightInfo = pallet_bridge_messages::weights::BridgeWeight;
type ActiveOutboundLanes = ActiveOutboundLanes;
- type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane;
- type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane;
- type MaximalOutboundPayloadSize = FromThisChainMaximalOutboundPayloadSize;
- type OutboundPayload = FromThisChainMessagePayload;
+ type OutboundPayload = XcmAsPlainPayload;
- type InboundPayload = FromBridgedChainMessagePayload;
- type InboundRelayer = BridgedChainAccountId;
+ type InboundPayload = Vec;
type DeliveryPayments = ();
- type TargetHeaderChain = TargetHeaderChainAdapter;
type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter<
TestRuntime,
(),
@@ -221,9 +199,11 @@ impl pallet_bridge_messages::Config for TestRuntime {
>;
type OnMessagesDelivered = ();
- type SourceHeaderChain = SourceHeaderChainAdapter;
type MessageDispatch = DummyMessageDispatch;
- type BridgedChainId = BridgedChainId;
+
+ type ThisChain = ThisUnderlyingChain;
+ type BridgedChain = BridgedUnderlyingChain;
+ type BridgedHeaderChain = BridgeGrandpa;
}
impl pallet_bridge_relayers::Config for TestRuntime {
@@ -262,55 +242,6 @@ impl MessageDispatch for DummyMessageDispatch {
}
}
-/// Bridge that is deployed on `ThisChain` and allows sending/receiving messages to/from
-/// `BridgedChain`.
-#[derive(Debug, PartialEq, Eq)]
-pub struct OnThisChainBridge;
-
-impl MessageBridge for OnThisChainBridge {
- const BRIDGED_MESSAGES_PALLET_NAME: &'static str = "";
-
- type ThisChain = ThisChain;
- type BridgedChain = BridgedChain;
- type BridgedHeaderChain = pallet_bridge_grandpa::GrandpaChainHeaders;
-}
-
-/// Bridge that is deployed on `BridgedChain` and allows sending/receiving messages to/from
-/// `ThisChain`.
-#[derive(Debug, PartialEq, Eq)]
-pub struct OnBridgedChainBridge;
-
-impl MessageBridge for OnBridgedChainBridge {
- const BRIDGED_MESSAGES_PALLET_NAME: &'static str = "";
-
- type ThisChain = BridgedChain;
- type BridgedChain = ThisChain;
- type BridgedHeaderChain = ThisHeaderChain;
-}
-
-/// Dummy implementation of `HeaderChain` for `ThisChain` at the `BridgedChain`.
-pub struct ThisHeaderChain;
-
-impl HeaderChain for ThisHeaderChain {
- fn finalized_header_state_root(_hash: HashOf) -> Option> {
- unreachable!()
- }
-}
-
-/// Call origin at `BridgedChain`.
-#[derive(Clone, Debug)]
-pub struct BridgedChainOrigin;
-
-impl From
- for Result, BridgedChainOrigin>
-{
- fn from(
- _origin: BridgedChainOrigin,
- ) -> Result, BridgedChainOrigin> {
- unreachable!()
- }
-}
-
/// Underlying chain of `ThisChain`.
pub struct ThisUnderlyingChain;
@@ -326,6 +257,8 @@ impl Chain for ThisUnderlyingChain {
type Nonce = u32;
type Signature = sp_runtime::MultiSignature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
BRIDGED_CHAIN_MAX_EXTRINSIC_SIZE
}
@@ -335,29 +268,20 @@ impl Chain for ThisUnderlyingChain {
}
}
-/// The chain where we are in tests.
-pub struct ThisChain;
-
-impl UnderlyingChainProvider for ThisChain {
- type Chain = ThisUnderlyingChain;
-}
+impl ChainWithMessages for ThisUnderlyingChain {
+ const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "";
-impl ThisChainWithMessages for ThisChain {
- type RuntimeOrigin = ThisChainCallOrigin;
+ const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16;
+ const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 1000;
}
-impl BridgedChainWithMessages for ThisChain {}
-
/// Underlying chain of `BridgedChain`.
pub struct BridgedUnderlyingChain;
/// Some parachain under `BridgedChain` consensus.
pub struct BridgedUnderlyingParachain;
-/// Runtime call of the `BridgedChain`.
-#[derive(Decode, Encode)]
-pub struct BridgedChainCall;
impl Chain for BridgedUnderlyingChain {
- const ID: ChainId = *b"buch";
+ const ID: ChainId = TEST_BRIDGED_CHAIN_ID;
type BlockNumber = BridgedChainBlockNumber;
type Hash = BridgedChainHash;
@@ -368,6 +292,8 @@ impl Chain for BridgedUnderlyingChain {
type Nonce = u32;
type Signature = sp_runtime::MultiSignature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
BRIDGED_CHAIN_MAX_EXTRINSIC_SIZE
}
@@ -384,6 +310,12 @@ impl ChainWithGrandpa for BridgedUnderlyingChain {
const AVERAGE_HEADER_SIZE: u32 = 64;
}
+impl ChainWithMessages for BridgedUnderlyingChain {
+ const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "";
+ const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16;
+ const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 1000;
+}
+
impl Chain for BridgedUnderlyingParachain {
const ID: ChainId = *b"bupc";
@@ -396,6 +328,8 @@ impl Chain for BridgedUnderlyingParachain {
type Nonce = u32;
type Signature = sp_runtime::MultiSignature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
BRIDGED_CHAIN_MAX_EXTRINSIC_SIZE
}
@@ -409,19 +343,6 @@ impl Parachain for BridgedUnderlyingParachain {
const MAX_HEADER_SIZE: u32 = 1_024;
}
-/// The other, bridged chain, used in tests.
-pub struct BridgedChain;
-
-impl UnderlyingChainProvider for BridgedChain {
- type Chain = BridgedUnderlyingChain;
-}
-
-impl ThisChainWithMessages for BridgedChain {
- type RuntimeOrigin = BridgedChainOrigin;
-}
-
-impl BridgedChainWithMessages for BridgedChain {}
-
/// Run test within test externalities.
pub fn run_test(test: impl FnOnce()) {
sp_io::TestExternalities::new(Default::default()).execute_with(test)
diff --git a/bridges/bin/runtime-common/src/parachains_benchmarking.rs b/bridges/bin/runtime-common/src/parachains_benchmarking.rs
index b3050b9ac0f3ccec617399d3eb91647dcab7eb3d..bcbd779b44dea5fbef7781335cfa1d359ab8c1f1 100644
--- a/bridges/bin/runtime-common/src/parachains_benchmarking.rs
+++ b/bridges/bin/runtime-common/src/parachains_benchmarking.rs
@@ -18,14 +18,11 @@
#![cfg(feature = "runtime-benchmarks")]
-use crate::{
- messages_benchmarking::insert_header_to_grandpa_pallet,
- messages_generation::grow_trie_leaf_value,
-};
+use crate::messages_benchmarking::insert_header_to_grandpa_pallet;
use bp_parachains::parachain_head_storage_key_at_source;
use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId};
-use bp_runtime::{record_all_trie_keys, StorageProofSize};
+use bp_runtime::{grow_storage_value, record_all_trie_keys, Chain, UnverifiedStorageProofParams};
use codec::Encode;
use frame_support::traits::Get;
use pallet_bridge_parachains::{RelayBlockHash, RelayBlockHasher, RelayBlockNumber};
@@ -39,14 +36,14 @@ use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut};
pub fn prepare_parachain_heads_proof(
parachains: &[ParaId],
parachain_head_size: u32,
- size: StorageProofSize,
+ proof_params: UnverifiedStorageProofParams,
) -> (RelayBlockNumber, RelayBlockHash, ParaHeadsProof, Vec<(ParaId, ParaHash)>)
where
R: pallet_bridge_parachains::Config
+ pallet_bridge_grandpa::Config,
PI: 'static,
>::BridgedChain:
- bp_runtime::Chain,
+ Chain,
{
let parachain_head = ParaHead(vec![0u8; parachain_head_size as usize]);
@@ -64,7 +61,7 @@ where
let storage_key =
parachain_head_storage_key_at_source(R::ParasPalletName::get(), *parachain);
let leaf_data = if i == 0 {
- grow_trie_leaf_value(parachain_head.encode(), size)
+ grow_storage_value(parachain_head.encode(), &proof_params)
} else {
parachain_head.encode()
};
diff --git a/bridges/chains/chain-asset-hub-rococo/Cargo.toml b/bridges/chains/chain-asset-hub-rococo/Cargo.toml
index d9afe2c8bf76713104beead1ad4c36dc08dae1ed..363a869048aae4d875d68a8ca46e30756cbc799f 100644
--- a/bridges/chains/chain-asset-hub-rococo/Cargo.toml
+++ b/bridges/chains/chain-asset-hub-rococo/Cargo.toml
@@ -7,18 +7,21 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+codec = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
# Substrate Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
+frame-support = { workspace = true }
# Bridge Dependencies
-bp-xcm-bridge-hub-router = { path = "../../primitives/xcm-bridge-hub-router", default-features = false }
+bp-xcm-bridge-hub-router = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-asset-hub-westend/Cargo.toml b/bridges/chains/chain-asset-hub-westend/Cargo.toml
index 4b3ed052f1382d0c7f076ad5152c861f60d8bef1..430d9b6116cfc7fba648b96b1de6ef379f3e38f3 100644
--- a/bridges/chains/chain-asset-hub-westend/Cargo.toml
+++ b/bridges/chains/chain-asset-hub-westend/Cargo.toml
@@ -7,18 +7,21 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+codec = { workspace = true }
+scale-info = { features = ["derive"], workspace = true }
# Substrate Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
+frame-support = { workspace = true }
# Bridge Dependencies
-bp-xcm-bridge-hub-router = { path = "../../primitives/xcm-bridge-hub-router", default-features = false }
+bp-xcm-bridge-hub-router = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-cumulus/Cargo.toml b/bridges/chains/chain-bridge-hub-cumulus/Cargo.toml
index 4b900002a4d81abb9d7364f555a150a2af6c839c..99ba721991ee90b04e708beb37dcca2f0aa5c96c 100644
--- a/bridges/chains/chain-bridge-hub-cumulus/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-cumulus/Cargo.toml
@@ -7,25 +7,28 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
# Bridge Dependencies
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-polkadot-core = { workspace = true }
+bp-messages = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-system = { workspace = true }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
# Polkadot Dependencies
-polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false }
+polkadot-primitives = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-kusama/Cargo.toml b/bridges/chains/chain-bridge-hub-kusama/Cargo.toml
index ff6dd8849abe3897f1c3eb3cb1de8b7d89af5ca7..39f7b44daa5543b83108761d7acf5f72d5a8458f 100644
--- a/bridges/chains/chain-bridge-hub-kusama/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-kusama/Cargo.toml
@@ -7,22 +7,25 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
# Bridge Dependencies
-bp-bridge-hub-cumulus = { path = "../chain-bridge-hub-cumulus", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
+bp-bridge-hub-cumulus = { workspace = true }
+bp-runtime = { workspace = true }
+bp-messages = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-kusama/src/lib.rs b/bridges/chains/chain-bridge-hub-kusama/src/lib.rs
index ef3ef4ab7b7a9bc111218e3c53091ac232f34721..c990e8a12f367cafbd35b0693b323a6ec5fb5e96 100644
--- a/bridges/chains/chain-bridge-hub-kusama/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-kusama/src/lib.rs
@@ -29,7 +29,7 @@ use frame_support::{
dispatch::DispatchClass,
sp_runtime::{MultiAddress, MultiSigner},
};
-use sp_runtime::RuntimeDebug;
+use sp_runtime::{RuntimeDebug, StateVersion};
/// BridgeHubKusama parachain.
#[derive(RuntimeDebug)]
@@ -48,6 +48,8 @@ impl Chain for BridgeHubKusama {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
*BlockLength::get().max.get(DispatchClass::Normal)
}
diff --git a/bridges/chains/chain-bridge-hub-polkadot/Cargo.toml b/bridges/chains/chain-bridge-hub-polkadot/Cargo.toml
index da8b8a82fa702eeab719335fa9968b78ee965163..3b0ac96e7cd367cd373cdaedcbeaf299af7debe0 100644
--- a/bridges/chains/chain-bridge-hub-polkadot/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-polkadot/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
@@ -14,16 +17,16 @@ workspace = true
# Bridge Dependencies
-bp-bridge-hub-cumulus = { path = "../chain-bridge-hub-cumulus", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
+bp-bridge-hub-cumulus = { workspace = true }
+bp-runtime = { workspace = true }
+bp-messages = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-polkadot/src/lib.rs b/bridges/chains/chain-bridge-hub-polkadot/src/lib.rs
index 9db71af928e5df01170cf4ab8bf5f20cd72f7610..7379b8863b1de5c1a1482db90077e958f0a33366 100644
--- a/bridges/chains/chain-bridge-hub-polkadot/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-polkadot/src/lib.rs
@@ -26,7 +26,7 @@ use bp_runtime::{
decl_bridge_finality_runtime_apis, decl_bridge_messages_runtime_apis, Chain, ChainId, Parachain,
};
use frame_support::dispatch::DispatchClass;
-use sp_runtime::RuntimeDebug;
+use sp_runtime::{RuntimeDebug, StateVersion};
/// BridgeHubPolkadot parachain.
#[derive(RuntimeDebug)]
@@ -45,6 +45,8 @@ impl Chain for BridgeHubPolkadot {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
*BlockLength::get().max.get(DispatchClass::Normal)
}
diff --git a/bridges/chains/chain-bridge-hub-rococo/Cargo.toml b/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
index f7672df012f2fc2a21cfc987468427a3222317ea..66848ba0e2634b3b4e525f27013b04768204c749 100644
--- a/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-rococo/Cargo.toml
@@ -7,22 +7,25 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
# Bridge Dependencies
-bp-bridge-hub-cumulus = { path = "../chain-bridge-hub-cumulus", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
+bp-bridge-hub-cumulus = { workspace = true }
+bp-runtime = { workspace = true }
+bp-messages = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-rococo/src/lib.rs b/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
index d7097f01c5316a58851f400a86b98eda3d7e8bcc..73af997b9950ef640040e44cbba0b93b6a7a56a3 100644
--- a/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-rococo/src/lib.rs
@@ -25,8 +25,10 @@ use bp_messages::*;
use bp_runtime::{
decl_bridge_finality_runtime_apis, decl_bridge_messages_runtime_apis, Chain, ChainId, Parachain,
};
-use frame_support::dispatch::DispatchClass;
-use sp_runtime::{MultiAddress, MultiSigner, RuntimeDebug};
+use frame_support::{
+ dispatch::DispatchClass,
+ sp_runtime::{MultiAddress, MultiSigner, RuntimeDebug, StateVersion},
+};
/// BridgeHubRococo parachain.
#[derive(RuntimeDebug)]
@@ -45,6 +47,8 @@ impl Chain for BridgeHubRococo {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
*BlockLength::get().max.get(DispatchClass::Normal)
}
@@ -103,10 +107,10 @@ frame_support::parameter_types! {
pub const BridgeHubRococoBaseXcmFeeInRocs: u128 = 59_034_266;
/// Transaction fee that is paid at the Rococo BridgeHub for delivering single inbound message.
- /// (initially was calculated by test `BridgeHubRococo::can_calculate_fee_for_complex_message_delivery_transaction` + `33%`)
+ /// (initially was calculated by test `BridgeHubRococo::can_calculate_fee_for_standalone_message_delivery_transaction` + `33%`)
pub const BridgeHubRococoBaseDeliveryFeeInRocs: u128 = 314_037_860;
/// Transaction fee that is paid at the Rococo BridgeHub for delivering single outbound message confirmation.
- /// (initially was calculated by test `BridgeHubRococo::can_calculate_fee_for_complex_message_confirmation_transaction` + `33%`)
+ /// (initially was calculated by test `BridgeHubRococo::can_calculate_fee_for_standalone_message_confirmation_transaction` + `33%`)
pub const BridgeHubRococoBaseConfirmationFeeInRocs: u128 = 57_414_813;
}
diff --git a/bridges/chains/chain-bridge-hub-westend/Cargo.toml b/bridges/chains/chain-bridge-hub-westend/Cargo.toml
index ec74c4b947d693dba92d4da5051526e49349e0a5..24a196c1d70d128c49ddb788a699fe6e22e6c359 100644
--- a/bridges/chains/chain-bridge-hub-westend/Cargo.toml
+++ b/bridges/chains/chain-bridge-hub-westend/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
@@ -14,16 +17,16 @@ workspace = true
# Bridge Dependencies
-bp-bridge-hub-cumulus = { path = "../chain-bridge-hub-cumulus", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
+bp-bridge-hub-cumulus = { workspace = true }
+bp-runtime = { workspace = true }
+bp-messages = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-bridge-hub-westend/src/lib.rs b/bridges/chains/chain-bridge-hub-westend/src/lib.rs
index 800f290d7bfa41cec4139e80a7dc9ea8962a6da5..17ff2c858a1d3eeae329cb972d95adc32952ede4 100644
--- a/bridges/chains/chain-bridge-hub-westend/src/lib.rs
+++ b/bridges/chains/chain-bridge-hub-westend/src/lib.rs
@@ -25,7 +25,7 @@ use bp_runtime::{
decl_bridge_finality_runtime_apis, decl_bridge_messages_runtime_apis, Chain, ChainId, Parachain,
};
use frame_support::dispatch::DispatchClass;
-use sp_runtime::RuntimeDebug;
+use sp_runtime::{RuntimeDebug, StateVersion};
/// BridgeHubWestend parachain.
#[derive(RuntimeDebug)]
@@ -44,6 +44,8 @@ impl Chain for BridgeHubWestend {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
*BlockLength::get().max.get(DispatchClass::Normal)
}
diff --git a/bridges/chains/chain-kusama/Cargo.toml b/bridges/chains/chain-kusama/Cargo.toml
index 66061ff2793cbdd3419fa8894ab78e37486102ea..aec4041f7d574243c07f3fefa66b8b6d4cb36057 100644
--- a/bridges/chains/chain-kusama/Cargo.toml
+++ b/bridges/chains/chain-kusama/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
@@ -14,15 +17,15 @@ workspace = true
# Bridge Dependencies
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-polkadot-core = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-kusama/src/lib.rs b/bridges/chains/chain-kusama/src/lib.rs
index fd7172c5869d468ff534e54f9ef6278cf86a88ed..dcd0b23abbbefa2dfba741d6934b5d5510c93017 100644
--- a/bridges/chains/chain-kusama/src/lib.rs
+++ b/bridges/chains/chain-kusama/src/lib.rs
@@ -23,7 +23,7 @@ pub use bp_polkadot_core::*;
use bp_header_chain::ChainWithGrandpa;
use bp_runtime::{decl_bridge_finality_runtime_apis, Chain, ChainId};
-use frame_support::weights::Weight;
+use frame_support::{sp_runtime::StateVersion, weights::Weight};
/// Kusama Chain
pub struct Kusama;
@@ -41,6 +41,8 @@ impl Chain for Kusama {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V0;
+
fn max_extrinsic_size() -> u32 {
max_extrinsic_size()
}
diff --git a/bridges/chains/chain-polkadot-bulletin/Cargo.toml b/bridges/chains/chain-polkadot-bulletin/Cargo.toml
index 700247b7055a891bec2d4a40bfd126720a0d952c..aecf9314273686f03a25b0f4e5988eabb157dfe7 100644
--- a/bridges/chains/chain-polkadot-bulletin/Cargo.toml
+++ b/bridges/chains/chain-polkadot-bulletin/Cargo.toml
@@ -7,27 +7,30 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false, features = ["derive"] }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+codec = { features = ["derive"], workspace = true }
+scale-info = { features = ["derive"], workspace = true }
# Bridge Dependencies
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-messages = { path = "../../primitives/messages", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-messages = { workspace = true }
+bp-polkadot-core = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-api = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-polkadot-bulletin/src/lib.rs b/bridges/chains/chain-polkadot-bulletin/src/lib.rs
index f3d300567f2b4f92cec272e0929a3c53d718c823..88980a9575016bd5c5e1428329454e8131a2075d 100644
--- a/bridges/chains/chain-polkadot-bulletin/src/lib.rs
+++ b/bridges/chains/chain-polkadot-bulletin/src/lib.rs
@@ -37,7 +37,9 @@ use frame_support::{
};
use frame_system::limits;
use scale_info::TypeInfo;
-use sp_runtime::{traits::DispatchInfoOf, transaction_validity::TransactionValidityError, Perbill};
+use sp_runtime::{
+ traits::DispatchInfoOf, transaction_validity::TransactionValidityError, Perbill, StateVersion,
+};
// This chain reuses most of Polkadot primitives.
pub use bp_polkadot_core::{
@@ -192,6 +194,8 @@ impl Chain for PolkadotBulletin {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
*BlockLength::get().max.get(DispatchClass::Normal)
}
diff --git a/bridges/chains/chain-polkadot/Cargo.toml b/bridges/chains/chain-polkadot/Cargo.toml
index c700935f3083b5f287277c7d9975be53352b2506..50f637af4251c8a7ed822861281a217ec12bdb28 100644
--- a/bridges/chains/chain-polkadot/Cargo.toml
+++ b/bridges/chains/chain-polkadot/Cargo.toml
@@ -14,15 +14,15 @@ workspace = true
# Bridge Dependencies
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-polkadot-core = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-polkadot/src/lib.rs b/bridges/chains/chain-polkadot/src/lib.rs
index a8cac0467d574e9355a8fe9ba2e7c2378019349d..f4b262d40735d7470a4d7e289f24bc1d4556d039 100644
--- a/bridges/chains/chain-polkadot/src/lib.rs
+++ b/bridges/chains/chain-polkadot/src/lib.rs
@@ -25,7 +25,7 @@ use bp_header_chain::ChainWithGrandpa;
use bp_runtime::{
decl_bridge_finality_runtime_apis, extensions::PrevalidateAttests, Chain, ChainId,
};
-use frame_support::weights::Weight;
+use frame_support::{sp_runtime::StateVersion, weights::Weight};
/// Polkadot Chain
pub struct Polkadot;
@@ -43,6 +43,8 @@ impl Chain for Polkadot {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V0;
+
fn max_extrinsic_size() -> u32 {
max_extrinsic_size()
}
diff --git a/bridges/chains/chain-rococo/Cargo.toml b/bridges/chains/chain-rococo/Cargo.toml
index 5a5613bb376a5a4f75c773b3350993262149f973..8a99267691dc218d924fd0786e9fc45a5baa7f3c 100644
--- a/bridges/chains/chain-rococo/Cargo.toml
+++ b/bridges/chains/chain-rococo/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
@@ -14,15 +17,15 @@ workspace = true
# Bridge Dependencies
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-polkadot-core = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-rococo/src/lib.rs b/bridges/chains/chain-rococo/src/lib.rs
index b290fe71c829d08130556a2b061c0d63f0787d4c..bfcafdf41ea2e629c9a58f2545016b2e776375b8 100644
--- a/bridges/chains/chain-rococo/src/lib.rs
+++ b/bridges/chains/chain-rococo/src/lib.rs
@@ -23,7 +23,7 @@ pub use bp_polkadot_core::*;
use bp_header_chain::ChainWithGrandpa;
use bp_runtime::{decl_bridge_finality_runtime_apis, Chain, ChainId};
-use frame_support::weights::Weight;
+use frame_support::{sp_runtime::StateVersion, weights::Weight};
/// Rococo Chain
pub struct Rococo;
@@ -41,6 +41,8 @@ impl Chain for Rococo {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
max_extrinsic_size()
}
diff --git a/bridges/chains/chain-westend/Cargo.toml b/bridges/chains/chain-westend/Cargo.toml
index 10b06d76507ef95bbff00f5560b705ecee1ec4ce..cd6abe8abe6d69d5e5b9aa65d3ff7861c42d23cf 100644
--- a/bridges/chains/chain-westend/Cargo.toml
+++ b/bridges/chains/chain-westend/Cargo.toml
@@ -7,6 +7,9 @@ edition.workspace = true
license = "GPL-3.0-or-later WITH Classpath-exception-2.0"
repository.workspace = true
+[package.metadata.polkadot-sdk]
+exclude-from-umbrella = true
+
[lints]
workspace = true
@@ -14,15 +17,15 @@ workspace = true
# Bridge Dependencies
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
-bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-polkadot-core = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Based Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-sp-api = { path = "../../../substrate/primitives/api", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+sp-api = { workspace = true }
+sp-std = { workspace = true }
[features]
default = ["std"]
diff --git a/bridges/chains/chain-westend/src/lib.rs b/bridges/chains/chain-westend/src/lib.rs
index ef451f7de0a9640bc1a278e1c712bbb099193ceb..2a247e03e59d666d3c5dd54d74e3a4f852a60bd3 100644
--- a/bridges/chains/chain-westend/src/lib.rs
+++ b/bridges/chains/chain-westend/src/lib.rs
@@ -23,7 +23,7 @@ pub use bp_polkadot_core::*;
use bp_header_chain::ChainWithGrandpa;
use bp_runtime::{decl_bridge_finality_runtime_apis, Chain, ChainId};
-use frame_support::weights::Weight;
+use frame_support::{sp_runtime::StateVersion, weights::Weight};
/// Westend Chain
pub struct Westend;
@@ -41,6 +41,8 @@ impl Chain for Westend {
type Nonce = Nonce;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
max_extrinsic_size()
}
diff --git a/bridges/modules/beefy/Cargo.toml b/bridges/modules/beefy/Cargo.toml
index e36bbb615f23a20d4ef4a4f4ea8418e752d5b01f..cffc62d290828f032c5c57f27982e7f60f9b94ef 100644
--- a/bridges/modules/beefy/Cargo.toml
+++ b/bridges/modules/beefy/Cargo.toml
@@ -12,32 +12,32 @@ publish = false
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
+codec = { workspace = true }
log = { workspace = true }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+scale-info = { features = ["derive"], workspace = true }
serde = { optional = true, workspace = true }
# Bridge Dependencies
-bp-beefy = { path = "../../primitives/beefy", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-beefy = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-sp-core = { path = "../../../substrate/primitives/core", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-core = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
[dev-dependencies]
-sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy" }
-mmr-lib = { package = "ckb-merkle-mountain-range", version = "0.5.2" }
-pallet-beefy-mmr = { path = "../../../substrate/frame/beefy-mmr" }
-pallet-mmr = { path = "../../../substrate/frame/merkle-mountain-range" }
-rand = "0.8.5"
-sp-io = { path = "../../../substrate/primitives/io" }
-bp-test-utils = { path = "../../primitives/test-utils" }
+sp-consensus-beefy = { workspace = true, default-features = true }
+mmr-lib = { workspace = true }
+pallet-beefy-mmr = { workspace = true, default-features = true }
+pallet-mmr = { workspace = true, default-features = true }
+rand = { workspace = true, default-features = true }
+sp-io = { workspace = true, default-features = true }
+bp-test-utils = { workspace = true, default-features = true }
[features]
default = ["std"]
diff --git a/bridges/modules/beefy/src/mock.rs b/bridges/modules/beefy/src/mock.rs
index c99566b6b06d1855319d614f4f4ddfbf2fb1918b..3b751ddf066c9562cd8fc0f054b1b103306479dd 100644
--- a/bridges/modules/beefy/src/mock.rs
+++ b/bridges/modules/beefy/src/mock.rs
@@ -29,6 +29,7 @@ use sp_core::{sr25519::Signature, Pair};
use sp_runtime::{
testing::{Header, H256},
traits::{BlakeTwo256, Hash},
+ StateVersion,
};
pub use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Pair as BeefyPair};
@@ -66,7 +67,7 @@ construct_runtime! {
}
}
-#[derive_impl(frame_system::config_preludes::TestDefaultConfig as frame_system::DefaultConfig)]
+#[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
impl frame_system::Config for TestRuntime {
type Block = Block;
}
@@ -93,6 +94,8 @@ impl Chain for TestBridgedChain {
type Nonce = u64;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
unreachable!()
}
diff --git a/bridges/modules/grandpa/Cargo.toml b/bridges/modules/grandpa/Cargo.toml
index 0ca6b67503511976ea9122f64e3c2e515e971177..6d1419ae5b030733ad9fb38a6a459ab7ce34f99f 100644
--- a/bridges/modules/grandpa/Cargo.toml
+++ b/bridges/modules/grandpa/Cargo.toml
@@ -13,32 +13,31 @@ workspace = true
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
-finality-grandpa = { version = "0.16.2", default-features = false }
+codec = { workspace = true }
log = { workspace = true }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+scale-info = { features = ["derive"], workspace = true }
# Bridge Dependencies
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
-bp-header-chain = { path = "../../primitives/header-chain", default-features = false }
+bp-runtime = { workspace = true }
+bp-header-chain = { workspace = true }
# Substrate Dependencies
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa", default-features = false, features = ["serde"] }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
-sp-trie = { path = "../../../substrate/primitives/trie", default-features = false }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-consensus-grandpa = { features = ["serde"], workspace = true }
+sp-runtime = { features = ["serde"], workspace = true }
+sp-std = { workspace = true }
# Optional Benchmarking Dependencies
-bp-test-utils = { path = "../../primitives/test-utils", default-features = false, optional = true }
-frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
+bp-test-utils = { optional = true, workspace = true }
+frame-benchmarking = { optional = true, workspace = true }
[dev-dependencies]
-sp-core = { path = "../../../substrate/primitives/core" }
-sp-io = { path = "../../../substrate/primitives/io" }
+bp-runtime = { features = ["test-helpers"], workspace = true }
+sp-core = { workspace = true, default-features = true }
+sp-io = { workspace = true, default-features = true }
[features]
default = ["std"]
@@ -47,7 +46,6 @@ std = [
"bp-runtime/std",
"bp-test-utils/std",
"codec/std",
- "finality-grandpa/std",
"frame-benchmarking/std",
"frame-support/std",
"frame-system/std",
@@ -56,7 +54,6 @@ std = [
"sp-consensus-grandpa/std",
"sp-runtime/std",
"sp-std/std",
- "sp-trie/std",
]
runtime-benchmarks = [
"bp-test-utils",
diff --git a/bridges/modules/grandpa/src/lib.rs b/bridges/modules/grandpa/src/lib.rs
index 3b77f676870e1a28b8367f1b14d24c9ca83ece4a..c62951b74656b052d4858dec2af1393e41553029 100644
--- a/bridges/modules/grandpa/src/lib.rs
+++ b/bridges/modules/grandpa/src/lib.rs
@@ -1443,11 +1443,14 @@ mod tests {
}
#[test]
- fn parse_finalized_storage_proof_rejects_proof_on_unknown_header() {
+ fn verify_storage_proof_rejects_unknown_header() {
run_test(|| {
assert_noop!(
- Pallet::::storage_proof_checker(Default::default(), vec![],)
- .map(|_| ()),
+ Pallet::::verify_storage_proof(
+ Default::default(),
+ Default::default(),
+ )
+ .map(|_| ()),
bp_header_chain::HeaderChainError::UnknownHeader,
);
});
@@ -1465,9 +1468,7 @@ mod tests {
>::put(HeaderId(2, hash));
>::insert(hash, header.build());
- assert_ok!(
- Pallet::::storage_proof_checker(hash, storage_proof).map(|_| ())
- );
+ assert_ok!(Pallet::::verify_storage_proof(hash, storage_proof).map(|_| ()));
});
}
diff --git a/bridges/modules/grandpa/src/mock.rs b/bridges/modules/grandpa/src/mock.rs
index 27df9d9c78f540d0d73f74c6a86ba19af30d4b6b..71af6182e057cca3d06b98ee6fe94283b93ab77d 100644
--- a/bridges/modules/grandpa/src/mock.rs
+++ b/bridges/modules/grandpa/src/mock.rs
@@ -20,7 +20,8 @@
use bp_header_chain::ChainWithGrandpa;
use bp_runtime::{Chain, ChainId};
use frame_support::{
- construct_runtime, derive_impl, parameter_types, traits::Hooks, weights::Weight,
+ construct_runtime, derive_impl, parameter_types, sp_runtime::StateVersion, traits::Hooks,
+ weights::Weight,
};
use sp_core::sr25519::Signature;
@@ -78,6 +79,8 @@ impl Chain for TestBridgedChain {
type Nonce = u64;
type Signature = Signature;
+ const STATE_VERSION: StateVersion = StateVersion::V1;
+
fn max_extrinsic_size() -> u32 {
unreachable!()
}
diff --git a/bridges/modules/messages/Cargo.toml b/bridges/modules/messages/Cargo.toml
index 71c86ccc0361708684d0a93166f858118dbf0d92..33f524030d264e4ed292f8f67273e838e15fc3a9 100644
--- a/bridges/modules/messages/Cargo.toml
+++ b/bridges/modules/messages/Cargo.toml
@@ -11,54 +11,69 @@ repository.workspace = true
workspace = true
[dependencies]
-codec = { package = "parity-scale-codec", version = "3.6.12", default-features = false }
+codec = { workspace = true }
log = { workspace = true }
-num-traits = { version = "0.2", default-features = false }
-scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
+scale-info = { features = ["derive"], workspace = true }
# Bridge dependencies
-
-bp-messages = { path = "../../primitives/messages", default-features = false }
-bp-runtime = { path = "../../primitives/runtime", default-features = false }
+bp-header-chain = { workspace = true }
+bp-messages = { workspace = true }
+bp-runtime = { workspace = true }
# Substrate Dependencies
-
-frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true }
-frame-support = { path = "../../../substrate/frame/support", default-features = false }
-frame-system = { path = "../../../substrate/frame/system", default-features = false }
-sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false }
-sp-std = { path = "../../../substrate/primitives/std", default-features = false }
+frame-benchmarking = { optional = true, workspace = true }
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+sp-runtime = { workspace = true }
+sp-std = { workspace = true }
+sp-trie = { optional = true, workspace = true }
[dev-dependencies]
-bp-test-utils = { path = "../../primitives/test-utils" }
-pallet-balances = { path = "../../../substrate/frame/balances" }
-sp-io = { path = "../../../substrate/primitives/io" }
+bp-runtime = { features = ["test-helpers"], workspace = true }
+bp-test-utils = { workspace = true }
+pallet-balances = { workspace = true }
+pallet-bridge-grandpa = { workspace = true }
+sp-io = { workspace = true }
+sp-core = { workspace = true }
[features]
default = ["std"]
std = [
+ "bp-header-chain/std",
"bp-messages/std",
"bp-runtime/std",
+ "bp-test-utils/std",
"codec/std",
"frame-benchmarking/std",
"frame-support/std",
"frame-system/std",
"log/std",
- "num-traits/std",
+ "pallet-balances/std",
+ "pallet-bridge-grandpa/std",
"scale-info/std",
+ "sp-core/std",
+ "sp-io/std",
"sp-runtime/std",
"sp-std/std",
+ "sp-trie/std",
]
runtime-benchmarks = [
+ "bp-runtime/test-helpers",
"frame-benchmarking/runtime-benchmarks",
"frame-support/runtime-benchmarks",
"frame-system/runtime-benchmarks",
"pallet-balances/runtime-benchmarks",
+ "pallet-bridge-grandpa/runtime-benchmarks",
"sp-runtime/runtime-benchmarks",
]
try-runtime = [
"frame-support/try-runtime",
"frame-system/try-runtime",
"pallet-balances/try-runtime",
+ "pallet-bridge-grandpa/try-runtime",
"sp-runtime/try-runtime",
]
+test-helpers = [
+ "bp-runtime/test-helpers",
+ "sp-trie",
+]
diff --git a/bridges/modules/messages/README.md b/bridges/modules/messages/README.md
index c06b96b857dea1cdf7fdaed81e70d66aff116064..80fd92eb0e5a7d975ba45619838007a12f5f5553 100644
--- a/bridges/modules/messages/README.md
+++ b/bridges/modules/messages/README.md
@@ -104,17 +104,22 @@ the message. When a message is delivered to the target chain, the `MessagesDeliv
`receive_messages_delivery_proof()` transaction. The `MessagesDelivered` contains the message lane identifier and
inclusive range of delivered message nonces.
-The pallet provides no means to get the result of message dispatch at the target chain. If that is required, it must be
-done outside of the pallet. For example, XCM messages, when dispatched, have special instructions to send some data back
-to the sender. Other dispatchers may use similar mechanism for that.
-### How to plug-in Messages Module to Send Messages to the Bridged Chain?
-
-The `pallet_bridge_messages::Config` trait has 3 main associated types that are used to work with outbound messages. The
-`pallet_bridge_messages::Config::TargetHeaderChain` defines how we see the bridged chain as the target for our outbound
-messages. It must be able to check that the bridged chain may accept our message - like that the message has size below
-maximal possible transaction size of the chain and so on. And when the relayer sends us a confirmation transaction, this
-implementation must be able to parse and verify the proof of messages delivery. Normally, you would reuse the same
-(configurable) type on all chains that are sending messages to the same bridged chain.
+The pallet provides no means to get the result of message dispatch at the target chain. If that is
+required, it must be done outside of the pallet. For example, XCM messages, when dispatched, have
+special instructions to send some data back to the sender. Other dispatchers may use similar
+mechanism for that.
+
+### How to plug-in Messages Module to Send and Receive Messages from the Bridged Chain?
+
+The `pallet_bridge_messages::Config` trait has 2 main associated types that are used to work with
+inbound messages. The `pallet_bridge_messages::BridgedChain` defines basic primitives of the bridged
+chain. The `pallet_bridge_messages::BridgedHeaderChain` defines the way we access the bridged chain
+headers in our runtime. You may use `pallet_bridge_grandpa` if you're bridging with chain that uses
+GRANDPA finality or `pallet_bridge_parachains::ParachainHeaders` if you're bridging with parachain.
+
+The `pallet_bridge_messages::Config::MessageDispatch` defines a way on how to dispatch delivered
+messages. Apart from actually dispatching the message, the implementation must return the correct
+dispatch weight of the message before dispatch is called.
The last type is the `pallet_bridge_messages::Config::DeliveryConfirmationPayments`. When confirmation
transaction is received, we call the `pay_reward()` method, passing the range of delivered messages.
@@ -129,18 +134,6 @@ You should be looking at the `bp_messages::source_chain::ForbidOutboundMessages`
[`bp_messages::source_chain`](../../primitives/messages/src/source_chain.rs). It implements all required traits and will
simply reject all transactions, related to outbound messages.
-### How to plug-in Messages Module to Receive Messages from the Bridged Chain?
-
-The `pallet_bridge_messages::Config` trait has 2 main associated types that are used to work with inbound messages. The
-`pallet_bridge_messages::Config::SourceHeaderChain` defines how we see the bridged chain as the source of our inbound
-messages. When relayer sends us a delivery transaction, this implementation must be able to parse and verify the proof
-of messages wrapped in this transaction. Normally, you would reuse the same (configurable) type on all chains that are
-sending messages to the same bridged chain.
-
-The `pallet_bridge_messages::Config::MessageDispatch` defines a way on how to dispatch delivered messages. Apart from
-actually dispatching the message, the implementation must return the correct dispatch weight of the message before
-dispatch is called.
-
### I have a Messages Module in my Runtime, but I Want to Reject all Inbound Messages. What shall I do?
You should be looking at the `bp_messages::target_chain::ForbidInboundMessages` structure from the
@@ -150,36 +143,42 @@ and will simply reject all transactions, related to inbound messages.
### What about other Constants in the Messages Module Configuration Trait?
Two settings that are used to check messages in the `send_message()` function. The
-`pallet_bridge_messages::Config::ActiveOutboundLanes` is an array of all message lanes, that may be used to send
-messages. All messages sent using other lanes are rejected. All messages that have size above
-`pallet_bridge_messages::Config::MaximalOutboundPayloadSize` will also be rejected.
-
-To be able to reward the relayer for delivering messages, we store a map of message nonces range => identifier of the
-relayer that has delivered this range at the target chain runtime storage. If a relayer delivers multiple consequent
-ranges, they're merged into single entry. So there may be more than one entry for the same relayer. Eventually, this
-whole map must be delivered back to the source chain to confirm delivery and pay rewards. So to make sure we are able to
-craft this confirmation transaction, we need to: (1) keep the size of this map below a certain limit and (2) make sure
-that the weight of processing this map is below a certain limit. Both size and processing weight mostly depend on the
-number of entries. The number of entries is limited with the
-`pallet_bridge_messages::ConfigMaxUnrewardedRelayerEntriesAtInboundLane` parameter. Processing weight also depends on
-the total number of messages that are being confirmed, because every confirmed message needs to be read. So there's
-another `pallet_bridge_messages::Config::MaxUnconfirmedMessagesAtInboundLane` parameter for that.
-
-When choosing values for these parameters, you must also keep in mind that if proof in your scheme is based on finality
-of headers (and it is the most obvious option for Substrate-based chains with finality notion), then choosing too small
-values for these parameters may cause significant delays in message delivery. That's because there are too many actors
-involved in this scheme: 1) authorities that are finalizing headers of the target chain need to finalize header with
-non-empty map; 2) the headers relayer then needs to submit this header and its finality proof to the source chain; 3)
-the messages relayer must then send confirmation transaction (storage proof of this map) to the source chain; 4) when
-the confirmation transaction will be mined at some header, source chain authorities must finalize this header; 5) the
-headers relay then needs to submit this header and its finality proof to the target chain; 6) only now the messages
-relayer may submit new messages from the source to target chain and prune the entry from the map.
-
-Delivery transaction requires the relayer to provide both number of entries and total number of messages in the map.
-This means that the module never charges an extra cost for delivering a map - the relayer would need to pay exactly for
-the number of entries+messages it has delivered. So the best guess for values of these parameters would be the pair that
-would occupy `N` percent of the maximal transaction size and weight of the source chain. The `N` should be large enough
-to process large maps, at the same time keeping reserve for future source chain upgrades.
+`pallet_bridge_messages::Config::ActiveOutboundLanes` is an array of all message lanes, that
+may be used to send messages. All messages sent using other lanes are rejected. All messages that have
+size above `pallet_bridge_messages::Config::MaximalOutboundPayloadSize` will also be rejected.
+
+To be able to reward the relayer for delivering messages, we store a map of message nonces range =>
+identifier of the relayer that has delivered this range at the target chain runtime storage. If a
+relayer delivers multiple consequent ranges, they're merged into single entry. So there may be more
+than one entry for the same relayer. Eventually, this whole map must be delivered back to the source
+chain to confirm delivery and pay rewards. So to make sure we are able to craft this confirmation
+transaction, we need to: (1) keep the size of this map below a certain limit and (2) make sure that
+the weight of processing this map is below a certain limit. Both size and processing weight mostly
+depend on the number of entries. The number of entries is limited with the
+`pallet_bridge_messages::Config::BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` parameter.
+Processing weight also depends on the total number of messages that are being confirmed, because every
+confirmed message needs to be read. So there's another
+`pallet_bridge_messages::Config::BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX` parameter
+for that.
+
+When choosing values for these parameters, you must also keep in mind that if proof in your scheme
+is based on finality of headers (and it is the most obvious option for Substrate-based chains with
+finality notion), then choosing too small values for these parameters may cause significant delays
+in message delivery. That's because there are too many actors involved in this scheme: 1) authorities
+that are finalizing headers of the target chain need to finalize header with non-empty map; 2) the
+headers relayer then needs to submit this header and its finality proof to the source chain; 3) the
+messages relayer must then send confirmation transaction (storage proof of this map) to the source
+chain; 4) when the confirmation transaction will be mined at some header, source chain authorities
+must finalize this header; 5) the headers relay then needs to submit this header and its finality
+proof to the target chain; 6) only now the messages relayer may submit new messages from the source
+to target chain and prune the entry from the map.
+
+Delivery transaction requires the relayer to provide both number of entries and total number of
+messages in the map. This means that the module never charges an extra cost for delivering a map -
+the relayer would need to pay exactly for the number of entries+messages it has delivered. So the
+best guess for values of these parameters would be the pair that would occupy `N` percent of the
+maximal transaction size and weight of the source chain. The `N` should be large enough to process
+large maps, at the same time keeping reserve for future source chain upgrades.
## Non-Essential Functionality
diff --git a/bridges/modules/messages/src/benchmarking.rs b/bridges/modules/messages/src/benchmarking.rs
index 4f13c4409672b3e76d36fd7d3dd2fab5c7e2ec1b..d38aaf32dc94bd157de0d3e910b729a7970c1684 100644
--- a/bridges/modules/messages/src/benchmarking.rs
+++ b/bridges/modules/messages/src/benchmarking.rs
@@ -16,19 +16,22 @@
//! Messages pallet benchmarking.
+#![cfg(feature = "runtime-benchmarks")]
+
use crate::{
inbound_lane::InboundLaneStorage, outbound_lane, weights_ext::EXPECTED_DEFAULT_MESSAGE_LENGTH,
- Call, OutboundLanes, RuntimeInboundLaneStorage,
+ BridgedChainOf, Call, OutboundLanes, RuntimeInboundLaneStorage,
};
use bp_messages::{
- source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, DeliveredMessages,
+ source_chain::FromBridgedChainMessagesDeliveryProof,
+ target_chain::FromBridgedChainMessagesProof, ChainWithMessages, DeliveredMessages,
InboundLaneData, LaneId, MessageNonce, OutboundLaneData, UnrewardedRelayer,
UnrewardedRelayersState,
};
-use bp_runtime::StorageProofSize;
+use bp_runtime::{AccountIdOf, HashOf, UnverifiedStorageProofParams};
use codec::Decode;
-use frame_benchmarking::{account, benchmarks_instance_pallet};
+use frame_benchmarking::{account, v2::*};
use frame_support::weights::Weight;
use frame_system::RawOrigin;
use sp_runtime::{traits::TrailingZeroInput, BoundedVec};
@@ -54,7 +57,7 @@ pub struct MessageProofParams {
/// return `true` from the `is_message_successfully_dispatched`.
pub is_successful_dispatch_expected: bool,
/// Proof size requirements.
- pub size: StorageProofSize,
+ pub proof_params: UnverifiedStorageProofParams,
}
/// Benchmark-specific message delivery proof parameters.
@@ -65,7 +68,7 @@ pub struct MessageDeliveryProofParams {
/// The proof needs to include this inbound lane data.
pub inbound_lane_data: InboundLaneData,
/// Proof size requirements.
- pub size: StorageProofSize,
+ pub proof_params: UnverifiedStorageProofParams,
}
/// Trait that must be implemented by runtime.
@@ -80,8 +83,8 @@ pub trait Config 
+
+# {name}
+
+This crate is part of the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk/).
+
+